cairo_status_t _cairo_surface_clipper_set_clip (cairo_surface_clipper_t *clipper, cairo_clip_t *clip) { cairo_status_t status; cairo_bool_t clear; /* XXX as we cache a reference to the path, and compare every time, * we may in future need to install a notification if the clip->path * is every modified (e.g. cairo_clip_translate). */ if (clip == NULL && clipper->clip.path == NULL) return CAIRO_STATUS_SUCCESS; if (clip != NULL && clip->path == clipper->clip.path) return CAIRO_STATUS_SUCCESS; if (clip != NULL && clipper->clip.path != NULL && _cairo_path_fixed_equal (&clip->path->path, &clipper->clip.path->path)) { return CAIRO_STATUS_SUCCESS; } /* all clipped out state should never propagate this far */ assert (clip == NULL || clip->path != NULL); /* Check whether this clip is a continuation of the previous. * If not, we have to remove the current clip and rebuild. */ clear = clip == NULL || clip->path->prev != clipper->clip.path; _cairo_clip_reset (&clipper->clip); _cairo_clip_init_copy (&clipper->clip, clip); if (clear) { clipper->is_clipped = FALSE; status = clipper->intersect_clip_path (clipper, NULL, 0, 0, 0); if (unlikely (status)) return status; if (clip != NULL && clip->path != NULL) { status = _cairo_surface_clipper_intersect_clip_path_recursive (clipper, clip->path); clipper->is_clipped = TRUE; } } else { cairo_clip_path_t *path = clip->path; clipper->is_clipped = TRUE; status = clipper->intersect_clip_path (clipper, &path->path, path->fill_rule, path->tolerance, path->antialias); } return status; }
static void _cairo_clip_set_all_clipped (cairo_clip_t *clip, cairo_surface_t *target) { _cairo_clip_reset (clip); clip->all_clipped = TRUE; clip->serial = _cairo_surface_allocate_clip_serial (target); }
cairo_status_t _cairo_surface_wrapper_fill (cairo_surface_wrapper_t *wrapper, cairo_operator_t op, const cairo_pattern_t *source, cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, double tolerance, cairo_antialias_t antialias, cairo_clip_t *clip) { cairo_status_t status; cairo_matrix_t device_transform; cairo_path_fixed_t path_copy, *dev_path = path; cairo_clip_t clip_copy, *dev_clip = clip; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (_cairo_surface_wrapper_needs_device_transform (wrapper, &device_transform)) { status = _cairo_path_fixed_init_copy (&path_copy, dev_path); if (unlikely (status)) goto FINISH; _cairo_path_fixed_transform (&path_copy, &device_transform); dev_path = &path_copy; if (clip != NULL) { status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &device_transform); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } } else { if (clip != NULL) { dev_clip = &clip_copy; _cairo_clip_init_copy (&clip_copy, clip); } } status = _cairo_surface_fill (wrapper->target, op, source, dev_path, fill_rule, tolerance, antialias, dev_clip); FINISH: if (dev_path != path) _cairo_path_fixed_fini (dev_path); if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
cairo_status_t _cairo_surface_offset_mask (cairo_surface_t *target, int x, int y, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t clip_copy, *dev_clip = clip; cairo_pattern_union_t source_copy; cairo_pattern_union_t mask_copy; if (unlikely (target->status)) return target->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (x | y) { cairo_matrix_t m; if (clip != NULL) { cairo_matrix_init_translate (&m, -x, -y); status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); _copy_transformed_pattern (&mask_copy.base, mask, &m); source = &source_copy.base; mask = &mask_copy.base; } status = _cairo_surface_mask (target, op, &source_copy.base, &mask_copy.base, dev_clip); FINISH: if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
cairo_status_t _cairo_surface_wrapper_mask (cairo_surface_wrapper_t *wrapper, cairo_operator_t op, const cairo_pattern_t *source, const cairo_pattern_t *mask, cairo_clip_t *clip) { cairo_status_t status; cairo_matrix_t device_transform; cairo_clip_t clip_copy, *dev_clip = clip; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (clip != NULL) { if (_cairo_surface_wrapper_needs_device_transform (wrapper, &device_transform)) { status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &device_transform); if (unlikely (status)) goto FINISH; } else { _cairo_clip_init_copy (&clip_copy, clip); } dev_clip = &clip_copy; } status = _cairo_surface_mask (wrapper->target, op, source, mask, dev_clip); FINISH: if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
cairo_status_t _cairo_surface_wrapper_show_text_glyphs (cairo_surface_wrapper_t *wrapper, cairo_operator_t op, const cairo_pattern_t *source, const char *utf8, int utf8_len, cairo_glyph_t *glyphs, int num_glyphs, const cairo_text_cluster_t *clusters, int num_clusters, cairo_text_cluster_flags_t cluster_flags, cairo_scaled_font_t *scaled_font, cairo_clip_t *clip) { cairo_status_t status; cairo_matrix_t device_transform; cairo_clip_t clip_copy, *dev_clip = clip; cairo_glyph_t *dev_glyphs = glyphs; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (glyphs == NULL || num_glyphs == 0) return CAIRO_STATUS_SUCCESS; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (_cairo_surface_wrapper_needs_device_transform (wrapper, &device_transform)) { int i; if (clip != NULL) { dev_clip = &clip_copy; status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &device_transform); if (unlikely (status)) goto FINISH; } dev_glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t)); if (dev_glyphs == NULL) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto FINISH; } for (i = 0; i < num_glyphs; i++) { dev_glyphs[i] = glyphs[i]; cairo_matrix_transform_point (&device_transform, &dev_glyphs[i].x, &dev_glyphs[i].y); } } else { if (clip != NULL) { dev_clip = &clip_copy; _cairo_clip_init_copy (&clip_copy, clip); } } status = _cairo_surface_show_text_glyphs (wrapper->target, op, source, utf8, utf8_len, dev_glyphs, num_glyphs, clusters, num_clusters, cluster_flags, scaled_font, dev_clip); FINISH: if (dev_clip != clip) _cairo_clip_reset (dev_clip); if (dev_glyphs != glyphs) free (dev_glyphs); return status; }
cairo_status_t _cairo_surface_wrapper_fill_stroke (cairo_surface_wrapper_t *wrapper, cairo_operator_t fill_op, const cairo_pattern_t *fill_source, cairo_fill_rule_t fill_rule, double fill_tolerance, cairo_antialias_t fill_antialias, cairo_path_fixed_t *path, cairo_operator_t stroke_op, const cairo_pattern_t *stroke_source, cairo_stroke_style_t *stroke_style, cairo_matrix_t *stroke_ctm, cairo_matrix_t *stroke_ctm_inverse, double stroke_tolerance, cairo_antialias_t stroke_antialias, cairo_clip_t *clip) { cairo_status_t status; cairo_matrix_t device_transform; cairo_path_fixed_t path_copy, *dev_path = path; cairo_clip_t clip_copy, *dev_clip = clip; cairo_matrix_t dev_ctm = *stroke_ctm; cairo_matrix_t dev_ctm_inverse = *stroke_ctm_inverse; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (_cairo_surface_wrapper_needs_device_transform (wrapper, &device_transform)) { status = _cairo_path_fixed_init_copy (&path_copy, dev_path); if (unlikely (status)) goto FINISH; _cairo_path_fixed_transform (&path_copy, &device_transform); dev_path = &path_copy; if (clip != NULL) { status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &device_transform); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } cairo_matrix_multiply (&dev_ctm, &dev_ctm, &device_transform); status = cairo_matrix_invert (&device_transform); assert (status == CAIRO_STATUS_SUCCESS); cairo_matrix_multiply (&dev_ctm_inverse, &device_transform, &dev_ctm_inverse); } else { if (clip != NULL) { dev_clip = &clip_copy; _cairo_clip_init_copy (&clip_copy, clip); } } status = _cairo_surface_fill_stroke (wrapper->target, fill_op, fill_source, fill_rule, fill_tolerance, fill_antialias, dev_path, stroke_op, stroke_source, stroke_style, &dev_ctm, &dev_ctm_inverse, stroke_tolerance, stroke_antialias, dev_clip); FINISH: if (dev_path != path) _cairo_path_fixed_fini (dev_path); if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
static cairo_status_t _cairo_meta_surface_replay_internal (cairo_surface_t *surface, cairo_surface_t *target, cairo_meta_replay_type_t type, cairo_meta_region_type_t region) { cairo_meta_surface_t *meta; cairo_command_t *command, **elements; int i, num_elements; cairo_int_status_t status, status2; cairo_clip_t clip, *old_clip; cairo_bool_t has_device_transform = _cairo_surface_has_device_transform (target); cairo_matrix_t *device_transform = &target->device_transform; cairo_path_fixed_t path_copy, *dev_path; if (surface->status) return surface->status; if (target->status) return _cairo_surface_set_error (surface, target->status); meta = (cairo_meta_surface_t *) surface; status = CAIRO_STATUS_SUCCESS; _cairo_clip_init (&clip, target); old_clip = _cairo_surface_get_clip (target); num_elements = meta->commands.num_elements; elements = _cairo_array_index (&meta->commands, 0); for (i = meta->replay_start_idx; i < num_elements; i++) { command = elements[i]; if (type == CAIRO_META_REPLAY && region != CAIRO_META_REGION_ALL) { if (command->header.region != region) continue; } /* For all commands except intersect_clip_path, we have to * ensure the current clip gets set on the surface. */ if (command->header.type != CAIRO_COMMAND_INTERSECT_CLIP_PATH) { status = _cairo_surface_set_clip (target, &clip); if (status) break; } dev_path = _cairo_command_get_path (command); if (dev_path && has_device_transform) { status = _cairo_path_fixed_init_copy (&path_copy, dev_path); if (status) break; _cairo_path_fixed_transform (&path_copy, device_transform); dev_path = &path_copy; } switch (command->header.type) { case CAIRO_COMMAND_PAINT: status = _cairo_surface_paint (target, command->paint.op, &command->paint.source.base); break; case CAIRO_COMMAND_MASK: status = _cairo_surface_mask (target, command->mask.op, &command->mask.source.base, &command->mask.mask.base); break; case CAIRO_COMMAND_STROKE: { cairo_matrix_t dev_ctm = command->stroke.ctm; cairo_matrix_t dev_ctm_inverse = command->stroke.ctm_inverse; if (has_device_transform) { cairo_matrix_multiply (&dev_ctm, &dev_ctm, device_transform); cairo_matrix_multiply (&dev_ctm_inverse, &target->device_transform_inverse, &dev_ctm_inverse); } status = _cairo_surface_stroke (target, command->stroke.op, &command->stroke.source.base, dev_path, &command->stroke.style, &dev_ctm, &dev_ctm_inverse, command->stroke.tolerance, command->stroke.antialias); break; } case CAIRO_COMMAND_FILL: { cairo_command_t *stroke_command; if (type != CAIRO_META_CREATE_REGIONS) stroke_command = (i < num_elements - 1) ? elements[i + 1] : NULL; else stroke_command = NULL; if (stroke_command != NULL && type == CAIRO_META_REPLAY && region != CAIRO_META_REGION_ALL) { if (stroke_command->header.region != region) stroke_command = NULL; } if (stroke_command != NULL && stroke_command->header.type == CAIRO_COMMAND_STROKE && _cairo_path_fixed_is_equal (dev_path, _cairo_command_get_path (stroke_command))) { cairo_matrix_t dev_ctm; cairo_matrix_t dev_ctm_inverse; dev_ctm = stroke_command->stroke.ctm; dev_ctm_inverse = stroke_command->stroke.ctm_inverse; if (has_device_transform) { cairo_matrix_multiply (&dev_ctm, &dev_ctm, device_transform); cairo_matrix_multiply (&dev_ctm_inverse, &surface->device_transform_inverse, &dev_ctm_inverse); } status = _cairo_surface_fill_stroke (target, command->fill.op, &command->fill.source.base, command->fill.fill_rule, command->fill.tolerance, command->fill.antialias, dev_path, stroke_command->stroke.op, &stroke_command->stroke.source.base, &stroke_command->stroke.style, &dev_ctm, &dev_ctm_inverse, stroke_command->stroke.tolerance, stroke_command->stroke.antialias); i++; } else status = _cairo_surface_fill (target, command->fill.op, &command->fill.source.base, dev_path, command->fill.fill_rule, command->fill.tolerance, command->fill.antialias); break; } case CAIRO_COMMAND_SHOW_TEXT_GLYPHS: { cairo_glyph_t *glyphs = command->show_text_glyphs.glyphs; cairo_glyph_t *dev_glyphs; int i, num_glyphs = command->show_text_glyphs.num_glyphs; /* show_text_glyphs is special because _cairo_surface_show_text_glyphs is allowed * to modify the glyph array that's passed in. We must always * copy the array before handing it to the backend. */ dev_glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t)); if (dev_glyphs == NULL) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); break; } if (has_device_transform) { for (i = 0; i < num_glyphs; i++) { dev_glyphs[i] = glyphs[i]; cairo_matrix_transform_point (device_transform, &dev_glyphs[i].x, &dev_glyphs[i].y); } } else { memcpy (dev_glyphs, glyphs, sizeof (cairo_glyph_t) * num_glyphs); } status = _cairo_surface_show_text_glyphs (target, command->show_text_glyphs.op, &command->show_text_glyphs.source.base, command->show_text_glyphs.utf8, command->show_text_glyphs.utf8_len, dev_glyphs, num_glyphs, command->show_text_glyphs.clusters, command->show_text_glyphs.num_clusters, command->show_text_glyphs.cluster_flags, command->show_text_glyphs.scaled_font); free (dev_glyphs); break; } case CAIRO_COMMAND_INTERSECT_CLIP_PATH: /* XXX Meta surface clipping is broken and requires some * cairo-gstate.c rewriting. Work around it for now. */ if (dev_path == NULL) _cairo_clip_reset (&clip); else status = _cairo_clip_clip (&clip, dev_path, command->intersect_clip_path.fill_rule, command->intersect_clip_path.tolerance, command->intersect_clip_path.antialias, target); break; default: ASSERT_NOT_REACHED; } if (dev_path == &path_copy) _cairo_path_fixed_fini (&path_copy); if (type == CAIRO_META_CREATE_REGIONS) { if (status == CAIRO_STATUS_SUCCESS) { command->header.region = CAIRO_META_REGION_NATIVE; } else if (status == CAIRO_INT_STATUS_IMAGE_FALLBACK) { command->header.region = CAIRO_META_REGION_IMAGE_FALLBACK; status = CAIRO_STATUS_SUCCESS; } } if (status) break; } _cairo_clip_reset (&clip); status2 = _cairo_surface_set_clip (target, old_clip); if (status == CAIRO_STATUS_SUCCESS) status = status2; return _cairo_surface_set_error (surface, status); }
cairo_status_t _cairo_surface_offset_glyphs (cairo_surface_t *surface, int x, int y, cairo_operator_t op, const cairo_pattern_t *source, cairo_scaled_font_t *scaled_font, cairo_glyph_t *glyphs, int num_glyphs, cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t clip_copy, *dev_clip = clip; cairo_pattern_union_t source_copy; cairo_glyph_t *dev_glyphs; int i; if (unlikely (surface->status)) return surface->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; dev_glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t)); if (dev_glyphs == NULL) return _cairo_error (CAIRO_STATUS_NO_MEMORY); memcpy (dev_glyphs, glyphs, sizeof (cairo_glyph_t) * num_glyphs); if (x | y) { cairo_matrix_t m; if (clip != NULL) { cairo_matrix_init_translate (&m, -x, -y); status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; for (i = 0; i < num_glyphs; i++) { dev_glyphs[i].x -= x; dev_glyphs[i].y -= y; } } status = _cairo_surface_show_text_glyphs (surface, op, source, NULL, 0, dev_glyphs, num_glyphs, NULL, 0, 0, scaled_font, dev_clip); FINISH: if (dev_clip != clip) _cairo_clip_reset (dev_clip); free (dev_glyphs); return status; }
cairo_status_t _cairo_surface_offset_fill (cairo_surface_t *surface, int x, int y, cairo_operator_t op, const cairo_pattern_t*source, cairo_path_fixed_t *path, cairo_fill_rule_t fill_rule, double tolerance, cairo_antialias_t antialias, cairo_clip_t *clip) { cairo_status_t status; cairo_path_fixed_t path_copy, *dev_path = path; cairo_clip_t clip_copy, *dev_clip = clip; cairo_pattern_union_t source_copy; if (unlikely (surface->status)) return surface->status; if (clip && clip->all_clipped) return CAIRO_STATUS_SUCCESS; if (x | y) { cairo_matrix_t m; status = _cairo_path_fixed_init_copy (&path_copy, dev_path); if (unlikely (status)) goto FINISH; _cairo_path_fixed_translate (&path_copy, _cairo_fixed_from_int (-x), _cairo_fixed_from_int (-y)); dev_path = &path_copy; if (clip != NULL) { cairo_matrix_init_translate (&m, -x, -y); status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } cairo_matrix_init_translate (&m, x, y); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; } status = _cairo_surface_fill (surface, op, source, dev_path, fill_rule, tolerance, antialias, dev_clip); FINISH: if (dev_path != path) _cairo_path_fixed_fini (dev_path); if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
static bool _cairo_qt_fast_fill (cairo_qt_surface_t *qs, const cairo_pattern_t *source, const cairo_path_fixed_t *path = NULL, cairo_fill_rule_t fill_rule = CAIRO_FILL_RULE_WINDING, double tolerance = 0.0, cairo_antialias_t antialias = CAIRO_ANTIALIAS_NONE) { #if ENABLE_FAST_FILL QImage *qsSrc_image = NULL; QPixmap *qsSrc_pixmap = NULL; std::auto_ptr<QImage> qsSrc_image_d; if (source->type == CAIRO_PATTERN_TYPE_SURFACE) { cairo_surface_pattern_t *spattern = (cairo_surface_pattern_t*) source; if (spattern->surface->type == CAIRO_SURFACE_TYPE_QT) { cairo_qt_surface_t *p = (cairo_qt_surface_t*) spattern->surface; qsSrc_image = p->image; qsSrc_pixmap = p->pixmap; } else if (spattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) { cairo_image_surface_t *p = (cairo_image_surface_t*) spattern->surface; qsSrc_image = new QImage((const uchar*) p->data, p->width, p->height, p->stride, _qimage_format_from_cairo_format(p->format)); qsSrc_image_d.reset(qsSrc_image); } } if (!qsSrc_image && !qsSrc_pixmap) return false; // We can only drawTiledPixmap; there's no drawTiledImage if (! qsSrc_pixmap && (source->extend == CAIRO_EXTEND_REPEAT || source->extend == CAIRO_EXTEND_REFLECT)) { return false; } QMatrix sourceMatrix = _qmatrix_from_cairo_matrix (source->matrix); // We can draw this faster by clipping and calling drawImage/drawPixmap. // Use our own clipping function so that we can get the // region handling to end up with the fastest possible clip. // // XXX Antialiasing will fail pretty hard here, since we can't clip with AA // with QPainter. qs->p->save(); if (path) { cairo_int_status_t status; cairo_clip_t clip, old_clip = qs->clipper.clip; _cairo_clip_init_copy (&clip, &qs->clipper.clip); status = (cairo_int_status_t) _cairo_clip_clip (&clip, path, fill_rule, tolerance, antialias); if (unlikely (status)) { qs->p->restore(); return false; } status = _cairo_qt_surface_set_clip (qs, &clip); if (unlikely (status)) { qs->p->restore(); return false; } _cairo_clip_reset (&clip); qs->clipper.clip = old_clip; } qs->p->setWorldMatrix (sourceMatrix.inverted(), true); switch (source->extend) { case CAIRO_EXTEND_REPEAT: // XXX handle reflect by tiling 4 times first case CAIRO_EXTEND_REFLECT: { assert (qsSrc_pixmap); // Render the tiling to cover the entire destination window (because // it'll be clipped). Transform the window rect by the inverse // of the current world transform so that the device coordinates // end up as the right thing. QRectF dest = qs->p->worldTransform().inverted().mapRect(QRectF(qs->window)); QPointF origin = sourceMatrix.map(QPointF(0.0, 0.0)); qs->p->drawTiledPixmap (dest, *qsSrc_pixmap, origin); } break; case CAIRO_EXTEND_NONE: case CAIRO_EXTEND_PAD: // XXX not exactly right, but good enough default: if (qsSrc_image) qs->p->drawImage (0, 0, *qsSrc_image); else if (qsSrc_pixmap) qs->p->drawPixmap (0, 0, *qsSrc_pixmap); break; } qs->p->restore(); return true; #else return false; #endif }
void _cairo_surface_clipper_reset (cairo_surface_clipper_t *clipper) { _cairo_clip_reset (&clipper->clip); clipper->is_clipped = FALSE; }
cairo_status_t _cairo_surface_wrapper_paint (cairo_surface_wrapper_t *wrapper, cairo_operator_t op, const cairo_pattern_t *source, cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t clip_copy, *dev_clip = clip; cairo_pattern_union_t source_copy; cairo_clip_t target_clip; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (wrapper->has_extents) { _cairo_clip_init_copy (&target_clip, clip); status = _cairo_clip_rectangle (&target_clip, &wrapper->extents); if (unlikely (status)) goto FINISH; dev_clip = clip = &target_clip; } if (clip && clip->all_clipped) { status = CAIRO_STATUS_SUCCESS; goto FINISH; } if (_cairo_surface_wrapper_needs_device_transform (wrapper) || _cairo_surface_wrapper_needs_extents_transform (wrapper)) { cairo_matrix_t m; cairo_matrix_init_identity (&m); if (_cairo_surface_wrapper_needs_extents_transform (wrapper)) cairo_matrix_translate (&m, -wrapper->extents.x, -wrapper->extents.y); if (_cairo_surface_wrapper_needs_device_transform (wrapper)) cairo_matrix_multiply (&m, &wrapper->target->device_transform, &m); if (clip != NULL) { status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } status = cairo_matrix_invert (&m); assert (status == CAIRO_STATUS_SUCCESS); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; } status = _cairo_surface_paint (wrapper->target, op, source, dev_clip); FINISH: if (wrapper->has_extents) _cairo_clip_reset (&target_clip); if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
cairo_status_t _cairo_surface_wrapper_show_text_glyphs (cairo_surface_wrapper_t *wrapper, cairo_operator_t op, const cairo_pattern_t *source, const char *utf8, int utf8_len, cairo_glyph_t *glyphs, int num_glyphs, const cairo_text_cluster_t *clusters, int num_clusters, cairo_text_cluster_flags_t cluster_flags, cairo_scaled_font_t *scaled_font, cairo_clip_t *clip) { cairo_status_t status; cairo_clip_t clip_copy, *dev_clip = clip; cairo_glyph_t *dev_glyphs = glyphs; cairo_pattern_union_t source_copy; cairo_clip_t target_clip; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (glyphs == NULL || num_glyphs == 0) return CAIRO_STATUS_SUCCESS; if (wrapper->has_extents) { _cairo_clip_init_copy (&target_clip, clip); status = _cairo_clip_rectangle (&target_clip, &wrapper->extents); if (unlikely (status)) goto FINISH; dev_clip = clip = &target_clip; } if (clip && clip->all_clipped) { status = CAIRO_STATUS_SUCCESS; goto FINISH; } if (_cairo_surface_wrapper_needs_device_transform (wrapper) || _cairo_surface_wrapper_needs_extents_transform (wrapper)) { cairo_matrix_t m; int i; cairo_matrix_init_identity (&m); if (_cairo_surface_wrapper_needs_extents_transform (wrapper)) cairo_matrix_translate (&m, -wrapper->extents.x, -wrapper->extents.y); if (_cairo_surface_wrapper_needs_device_transform (wrapper)) cairo_matrix_multiply (&m, &wrapper->target->device_transform, &m); if (clip != NULL) { status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } dev_glyphs = _cairo_malloc_ab (num_glyphs, sizeof (cairo_glyph_t)); if (dev_glyphs == NULL) { status = _cairo_error (CAIRO_STATUS_NO_MEMORY); goto FINISH; } for (i = 0; i < num_glyphs; i++) { dev_glyphs[i] = glyphs[i]; cairo_matrix_transform_point (&m, &dev_glyphs[i].x, &dev_glyphs[i].y); } status = cairo_matrix_invert (&m); assert (status == CAIRO_STATUS_SUCCESS); _copy_transformed_pattern (&source_copy.base, source, &m); source = &source_copy.base; } else { if (clip != NULL) { dev_clip = &clip_copy; _cairo_clip_init_copy (&clip_copy, clip); } } status = _cairo_surface_show_text_glyphs (wrapper->target, op, source, utf8, utf8_len, dev_glyphs, num_glyphs, clusters, num_clusters, cluster_flags, scaled_font, dev_clip); FINISH: if (dev_clip != clip) _cairo_clip_reset (dev_clip); if (wrapper->has_extents) _cairo_clip_reset (&target_clip); if (dev_glyphs != glyphs) free (dev_glyphs); return status; }
cairo_status_t _cairo_surface_wrapper_fill_stroke (cairo_surface_wrapper_t *wrapper, cairo_operator_t fill_op, const cairo_pattern_t *fill_source, cairo_fill_rule_t fill_rule, double fill_tolerance, cairo_antialias_t fill_antialias, cairo_path_fixed_t *path, cairo_operator_t stroke_op, const cairo_pattern_t *stroke_source, const cairo_stroke_style_t *stroke_style, const cairo_matrix_t *stroke_ctm, const cairo_matrix_t *stroke_ctm_inverse, double stroke_tolerance, cairo_antialias_t stroke_antialias, cairo_clip_t *clip) { cairo_status_t status; cairo_path_fixed_t path_copy, *dev_path = path; cairo_clip_t clip_copy, *dev_clip = clip; cairo_matrix_t dev_ctm = *stroke_ctm; cairo_matrix_t dev_ctm_inverse = *stroke_ctm_inverse; cairo_pattern_union_t stroke_source_copy; cairo_pattern_union_t fill_source_copy; cairo_clip_t target_clip; if (unlikely (wrapper->target->status)) return wrapper->target->status; if (wrapper->has_extents) { _cairo_clip_init_copy (&target_clip, clip); status = _cairo_clip_rectangle (&target_clip, &wrapper->extents); if (unlikely (status)) goto FINISH; dev_clip = clip = &target_clip; } if (clip && clip->all_clipped) { status = CAIRO_STATUS_SUCCESS; goto FINISH; } if (_cairo_surface_wrapper_needs_device_transform (wrapper) || _cairo_surface_wrapper_needs_extents_transform (wrapper)) { cairo_matrix_t m; cairo_matrix_init_identity (&m); if (_cairo_surface_wrapper_needs_extents_transform (wrapper)) cairo_matrix_translate (&m, -wrapper->extents.x, -wrapper->extents.y); if (_cairo_surface_wrapper_needs_device_transform (wrapper)) cairo_matrix_multiply (&m, &wrapper->target->device_transform, &m); status = _cairo_path_fixed_init_copy (&path_copy, dev_path); if (unlikely (status)) goto FINISH; _cairo_path_fixed_transform (&path_copy, &m); dev_path = &path_copy; if (clip != NULL) { status = _cairo_clip_init_copy_transformed (&clip_copy, clip, &m); if (unlikely (status)) goto FINISH; dev_clip = &clip_copy; } cairo_matrix_multiply (&dev_ctm, &dev_ctm, &m); status = cairo_matrix_invert (&m); assert (status == CAIRO_STATUS_SUCCESS); cairo_matrix_multiply (&dev_ctm_inverse, &m, &dev_ctm_inverse); _copy_transformed_pattern (&stroke_source_copy.base, stroke_source, &m); stroke_source = &stroke_source_copy.base; _copy_transformed_pattern (&fill_source_copy.base, fill_source, &m); fill_source = &fill_source_copy.base; } else { if (clip != NULL) { dev_clip = &clip_copy; _cairo_clip_init_copy (&clip_copy, clip); } } status = _cairo_surface_fill_stroke (wrapper->target, fill_op, fill_source, fill_rule, fill_tolerance, fill_antialias, dev_path, stroke_op, stroke_source, stroke_style, &dev_ctm, &dev_ctm_inverse, stroke_tolerance, stroke_antialias, dev_clip); FINISH: if (dev_path != path) _cairo_path_fixed_fini (dev_path); if (wrapper->has_extents) _cairo_clip_reset (&target_clip); if (dev_clip != clip) _cairo_clip_reset (dev_clip); return status; }
cairo_int_status_t _cairo_meta_surface_replay (cairo_surface_t *surface, cairo_surface_t *target) { cairo_meta_surface_t *meta; cairo_command_t *command, **elements; int i, num_elements; cairo_int_status_t status; cairo_traps_t traps; cairo_clip_t clip; meta = (cairo_meta_surface_t *) surface; status = CAIRO_STATUS_SUCCESS; _cairo_clip_init (&clip, target); num_elements = meta->commands.num_elements; elements = (cairo_command_t **) meta->commands.elements; for (i = 0; i < num_elements; i++) { command = elements[i]; switch (command->type) { case CAIRO_COMMAND_COMPOSITE: status = _cairo_surface_set_clip (target, &clip); if (status) break; status = _cairo_surface_composite (command->composite.operator, &command->composite.src_pattern.base, command->composite.mask_pattern_pointer, target, command->composite.src_x, command->composite.src_y, command->composite.mask_x, command->composite.mask_y, command->composite.dst_x, command->composite.dst_y, command->composite.width, command->composite.height); break; case CAIRO_COMMAND_FILL_RECTANGLES: status = _cairo_surface_set_clip (target, &clip); if (status) break; status = _cairo_surface_fill_rectangles (target, command->fill_rectangles.operator, &command->fill_rectangles.color, command->fill_rectangles.rects, command->fill_rectangles.num_rects); break; case CAIRO_COMMAND_COMPOSITE_TRAPEZOIDS: status = _cairo_surface_set_clip (target, &clip); if (status) break; status = _cairo_surface_composite_trapezoids (command->composite_trapezoids.operator, &command->composite_trapezoids.pattern.base, target, command->composite_trapezoids.antialias, command->composite_trapezoids.x_src, command->composite_trapezoids.y_src, command->composite_trapezoids.x_dst, command->composite_trapezoids.y_dst, command->composite_trapezoids.width, command->composite_trapezoids.height, command->composite_trapezoids.traps, command->composite_trapezoids.num_traps); break; case CAIRO_COMMAND_INTERSECT_CLIP_PATH: /* XXX Meta surface clipping is broken and requires some * cairo-gstate.c rewriting. Work around it for now. */ if (command->intersect_clip_path.path_pointer == NULL) status = _cairo_clip_reset (&clip); else status = _cairo_clip_clip (&clip, command->intersect_clip_path.path_pointer, command->intersect_clip_path.fill_rule, command->intersect_clip_path.tolerance, command->intersect_clip_path.antialias, target); break; case CAIRO_COMMAND_SHOW_GLYPHS: status = _cairo_surface_set_clip (target, &clip); if (status) break; status = _cairo_surface_show_glyphs (command->show_glyphs.scaled_font, command->show_glyphs.operator, &command->show_glyphs.pattern.base, target, command->show_glyphs.source_x, command->show_glyphs.source_y, command->show_glyphs.dest_x, command->show_glyphs.dest_y, command->show_glyphs.width, command->show_glyphs.height, command->show_glyphs.glyphs, command->show_glyphs.num_glyphs); if (status != CAIRO_INT_STATUS_UNSUPPORTED) break; status = (*command->show_glyphs.scaled_font->backend-> show_glyphs) (command->show_glyphs.scaled_font, command->show_glyphs.operator, &command->show_glyphs.pattern.base, target, command->show_glyphs.source_x, command->show_glyphs.source_y, command->show_glyphs.dest_x, command->show_glyphs.dest_y, command->show_glyphs.width, command->show_glyphs.height, command->show_glyphs.glyphs, command->show_glyphs.num_glyphs); break; case CAIRO_COMMAND_FILL_PATH: status = _cairo_surface_set_clip (target, &clip); if (status) break; status = _cairo_surface_fill_path (command->fill_path.operator, &command->fill_path.pattern.base, target, &command->fill_path.path, command->fill_path.fill_rule, command->fill_path.tolerance); if (status != CAIRO_INT_STATUS_UNSUPPORTED) break; _cairo_traps_init (&traps); status = _cairo_path_fixed_fill_to_traps (&command->fill_path.path, command->fill_path.fill_rule, command->fill_path.tolerance, &traps); if (status) { _cairo_traps_fini (&traps); break; } status = _cairo_surface_clip_and_composite_trapezoids (&command->fill_path.pattern.base, command->fill_path.operator, target, &traps, &clip, command->fill_path.antialias); _cairo_traps_fini (&traps); break; default: ASSERT_NOT_REACHED; } if (status) break; } _cairo_clip_fini (&clip); return status; }