?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
beta-0.89.2
[luatex.git] / source / libs / cairo / cairo-src / src / cairo-gstate.c
blobb4e988e96d809632af3c1a0f26bb458c8b3c107b
1 /* cairo - a vector graphics library with display and print output
2 *
3 * Copyright © 2002 University of Southern California
4 * Copyright © 2005 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it either under the terms of the GNU Lesser General Public
8 * License version 2.1 as published by the Free Software Foundation
9 * (the "LGPL") or, at your option, under the terms of the Mozilla
10 * Public License Version 1.1 (the "MPL"). If you do not alter this
11 * notice, a recipient may use your version of this file under either
12 * the MPL or the LGPL.
13 *
14 * You should have received a copy of the LGPL along with this library
15 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
17 * You should have received a copy of the MPL along with this library
18 * in the file COPYING-MPL-1.1
19 *
20 * The contents of this file are subject to the Mozilla Public License
21 * Version 1.1 (the "License"); you may not use this file except in
22 * compliance with the License. You may obtain a copy of the License at
23 * http://www.mozilla.org/MPL/
24 *
25 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
26 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
27 * the specific language governing rights and limitations.
28 *
29 * The Original Code is the cairo graphics library.
30 *
31 * The Initial Developer of the Original Code is University of Southern
32 * California.
33 *
34 * Contributor(s):
35 * Carl D. Worth <cworth@cworth.org>
36 */
37
38 #include "cairoint.h"
39
40 #include "cairo-clip-inline.h"
41 #include "cairo-clip-private.h"
42 #include "cairo-error-private.h"
43 #include "cairo-list-inline.h"
44 #include "cairo-gstate-private.h"
45 #include "cairo-pattern-private.h"
46 #include "cairo-traps-private.h"
47
48 #if _XOPEN_SOURCE >= 600 || defined (_ISOC99_SOURCE)
49 #define ISFINITE(x) isfinite (x)
50 #else
51 #define ISFINITE(x) ((x) * (x) >= 0.) /* check for NaNs */
52 #endif
53
54 static cairo_status_t
55 _cairo_gstate_init_copy (cairo_gstate_t *gstate, cairo_gstate_t *other);
56
57 static cairo_status_t
58 _cairo_gstate_ensure_font_face (cairo_gstate_t *gstate);
59
60 static cairo_status_t
61 _cairo_gstate_ensure_scaled_font (cairo_gstate_t *gstate);
62
63 static void
64 _cairo_gstate_unset_scaled_font (cairo_gstate_t *gstate);
65
66 static void
67 _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate,
68 const cairo_glyph_t *glyphs,
69 int num_glyphs,
70 const cairo_text_cluster_t *clusters,
71 int num_clusters,
72 cairo_text_cluster_flags_t cluster_flags,
73 cairo_glyph_t *transformed_glyphs,
74 int *num_transformed_glyphs,
75 cairo_text_cluster_t *transformed_clusters);
76
77 static void
78 _cairo_gstate_update_device_transform (cairo_observer_t *observer,
79 void *arg)
80 {
81 cairo_gstate_t *gstate = cairo_container_of (observer,
82 cairo_gstate_t,
83 device_transform_observer);
84
85 gstate->is_identity = (_cairo_matrix_is_identity (&gstate->ctm) &&
86 _cairo_matrix_is_identity (&gstate->target->device_transform));
87 }
88
89 cairo_status_t
90 _cairo_gstate_init (cairo_gstate_t *gstate,
91 cairo_surface_t *target)
92 {
93 VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));
94
95 gstate->next = NULL;
96
97 gstate->op = CAIRO_GSTATE_OPERATOR_DEFAULT;
98 gstate->opacity = 1.;
99
100 gstate->tolerance = CAIRO_GSTATE_TOLERANCE_DEFAULT;
101 gstate->antialias = CAIRO_ANTIALIAS_DEFAULT;
102
103 _cairo_stroke_style_init (&gstate->stroke_style);
104
105 gstate->fill_rule = CAIRO_GSTATE_FILL_RULE_DEFAULT;
106
107 gstate->font_face = NULL;
108 gstate->scaled_font = NULL;
109 gstate->previous_scaled_font = NULL;
110
111 cairo_matrix_init_scale (&gstate->font_matrix,
112 CAIRO_GSTATE_DEFAULT_FONT_SIZE,
113 CAIRO_GSTATE_DEFAULT_FONT_SIZE);
114
115 _cairo_font_options_init_default (&gstate->font_options);
116
117 gstate->clip = NULL;
118
119 gstate->target = cairo_surface_reference (target);
120 gstate->parent_target = NULL;
121 gstate->original_target = cairo_surface_reference (target);
122
123 gstate->device_transform_observer.callback = _cairo_gstate_update_device_transform;
124 cairo_list_add (&gstate->device_transform_observer.link,
125 &gstate->target->device_transform_observers);
126
127 gstate->is_identity = _cairo_matrix_is_identity (&gstate->target->device_transform);
128 cairo_matrix_init_identity (&gstate->ctm);
129 gstate->ctm_inverse = gstate->ctm;
130 gstate->source_ctm_inverse = gstate->ctm;
131
132 gstate->source = (cairo_pattern_t *) &_cairo_pattern_black.base;
133
134 /* Now that the gstate is fully initialized and ready for the eventual
135 * _cairo_gstate_fini(), we can check for errors (and not worry about
136 * the resource deallocation). */
137 return target->status;
138 }
139
140 /**
141 * _cairo_gstate_init_copy:
142 *
143 * Initialize @gstate by performing a deep copy of state fields from
144 * @other. Note that gstate->next is not copied but is set to %NULL by
145 * this function.
146 **/
147 static cairo_status_t
148 _cairo_gstate_init_copy (cairo_gstate_t *gstate, cairo_gstate_t *other)
149 {
150 cairo_status_t status;
151
152 VG (VALGRIND_MAKE_MEM_UNDEFINED (gstate, sizeof (cairo_gstate_t)));
153
154 gstate->op = other->op;
155 gstate->opacity = other->opacity;
156
157 gstate->tolerance = other->tolerance;
158 gstate->antialias = other->antialias;
159
160 status = _cairo_stroke_style_init_copy (&gstate->stroke_style,
161 &other->stroke_style);
162 if (unlikely (status))
163 return status;
164
165 gstate->fill_rule = other->fill_rule;
166
167 gstate->font_face = cairo_font_face_reference (other->font_face);
168 gstate->scaled_font = cairo_scaled_font_reference (other->scaled_font);
169 gstate->previous_scaled_font = cairo_scaled_font_reference (other->previous_scaled_font);
170
171 gstate->font_matrix = other->font_matrix;
172
173 _cairo_font_options_init_copy (&gstate->font_options , &other->font_options);
174
175 gstate->clip = _cairo_clip_copy (other->clip);
176
177 gstate->target = cairo_surface_reference (other->target);
178 /* parent_target is always set to NULL; it's only ever set by redirect_target */
179 gstate->parent_target = NULL;
180 gstate->original_target = cairo_surface_reference (other->original_target);
181
182 gstate->device_transform_observer.callback = _cairo_gstate_update_device_transform;
183 cairo_list_add (&gstate->device_transform_observer.link,
184 &gstate->target->device_transform_observers);
185
186 gstate->is_identity = other->is_identity;
187 gstate->ctm = other->ctm;
188 gstate->ctm_inverse = other->ctm_inverse;
189 gstate->source_ctm_inverse = other->source_ctm_inverse;
190
191 gstate->source = cairo_pattern_reference (other->source);
192
193 gstate->next = NULL;
194
195 return CAIRO_STATUS_SUCCESS;
196 }
197
198 void
199 _cairo_gstate_fini (cairo_gstate_t *gstate)
200 {
201 _cairo_stroke_style_fini (&gstate->stroke_style);
202
203 cairo_font_face_destroy (gstate->font_face);
204 gstate->font_face = NULL;
205
206 cairo_scaled_font_destroy (gstate->previous_scaled_font);
207 gstate->previous_scaled_font = NULL;
208
209 cairo_scaled_font_destroy (gstate->scaled_font);
210 gstate->scaled_font = NULL;
211
212 _cairo_clip_destroy (gstate->clip);
213
214 cairo_list_del (&gstate->device_transform_observer.link);
215
216 cairo_surface_destroy (gstate->target);
217 gstate->target = NULL;
218
219 cairo_surface_destroy (gstate->parent_target);
220 gstate->parent_target = NULL;
221
222 cairo_surface_destroy (gstate->original_target);
223 gstate->original_target = NULL;
224
225 cairo_pattern_destroy (gstate->source);
226 gstate->source = NULL;
227
228 VG (VALGRIND_MAKE_MEM_NOACCESS (gstate, sizeof (cairo_gstate_t)));
229 }
230
231 /**
232 * _cairo_gstate_save:
233 * @gstate: input/output gstate pointer
234 *
235 * Makes a copy of the current state of @gstate and saves it
236 * to @gstate->next, then put the address of the newly allcated
237 * copy into @gstate. _cairo_gstate_restore() reverses this.
238 **/
239 cairo_status_t
240 _cairo_gstate_save (cairo_gstate_t **gstate, cairo_gstate_t **freelist)
241 {
242 cairo_gstate_t *top;
243 cairo_status_t status;
244
245 if (CAIRO_INJECT_FAULT ())
246 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
247
248 top = *freelist;
249 if (top == NULL) {
250 top = malloc (sizeof (cairo_gstate_t));
251 if (unlikely (top == NULL))
252 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
253 } else
254 *freelist = top->next;
255
256 status = _cairo_gstate_init_copy (top, *gstate);
257 if (unlikely (status)) {
258 top->next = *freelist;
259 *freelist = top;
260 return status;
261 }
262
263 top->next = *gstate;
264 *gstate = top;
265
266 return CAIRO_STATUS_SUCCESS;
267 }
268
269 /**
270 * _cairo_gstate_restore:
271 * @gstate: input/output gstate pointer
272 *
273 * Reverses the effects of one _cairo_gstate_save() call.
274 **/
275 cairo_status_t
276 _cairo_gstate_restore (cairo_gstate_t **gstate, cairo_gstate_t **freelist)
277 {
278 cairo_gstate_t *top;
279
280 top = *gstate;
281 if (top->next == NULL)
282 return _cairo_error (CAIRO_STATUS_INVALID_RESTORE);
283
284 *gstate = top->next;
285
286 _cairo_gstate_fini (top);
287 VG (VALGRIND_MAKE_MEM_UNDEFINED (&top->next, sizeof (cairo_gstate_t *)));
288 top->next = *freelist;
289 *freelist = top;
290
291 return CAIRO_STATUS_SUCCESS;
292 }
293
294 /**
295 * _cairo_gstate_redirect_target:
296 * @gstate: a #cairo_gstate_t
297 * @child: the new child target
298 *
299 * Redirect @gstate rendering to a "child" target. The original
300 * "parent" target with which the gstate was created will not be
301 * affected. See _cairo_gstate_get_target().
302 **/
303 cairo_status_t
304 _cairo_gstate_redirect_target (cairo_gstate_t *gstate, cairo_surface_t *child)
305 {
306 /* If this gstate is already redirected, this is an error; we need a
307 * new gstate to be able to redirect */
308 assert (gstate->parent_target == NULL);
309
310 /* Set up our new parent_target based on our current target;
311 * gstate->parent_target will take the ref that is held by gstate->target
312 */
313 gstate->parent_target = gstate->target;
314
315 /* Now set up our new target; we overwrite gstate->target directly,
316 * since its ref is now owned by gstate->parent_target */
317 gstate->target = cairo_surface_reference (child);
318 gstate->is_identity &= _cairo_matrix_is_identity (&child->device_transform);
319 cairo_list_move (&gstate->device_transform_observer.link,
320 &gstate->target->device_transform_observers);
321
322 /* The clip is in surface backend coordinates for the previous target;
323 * translate it into the child's backend coordinates. */
324 _cairo_clip_destroy (gstate->clip);
325 gstate->clip = _cairo_clip_copy_with_translation (gstate->next->clip,
326 child->device_transform.x0 - gstate->parent_target->device_transform.x0,
327 child->device_transform.y0 - gstate->parent_target->device_transform.y0);
328
329 return CAIRO_STATUS_SUCCESS;
330 }
331
332 /**
333 * _cairo_gstate_is_group:
334 * @gstate: a #cairo_gstate_t
335 *
336 * Check if _cairo_gstate_redirect_target has been called on the head
337 * of the stack.
338 *
339 * Return value: %TRUE if @gstate is redirected to a target different
340 * than the previous state in the stack, %FALSE otherwise.
341 **/
342 cairo_bool_t
343 _cairo_gstate_is_group (cairo_gstate_t *gstate)
344 {
345 return gstate->parent_target != NULL;
346 }
347
348 /**
349 * _cairo_gstate_get_target:
350 * @gstate: a #cairo_gstate_t
351 *
352 * Return the current drawing target; if drawing is not redirected,
353 * this will be the same as _cairo_gstate_get_original_target().
354 *
355 * Return value: the current target surface
356 **/
357 cairo_surface_t *
358 _cairo_gstate_get_target (cairo_gstate_t *gstate)
359 {
360 return gstate->target;
361 }
362
363 /**
364 * _cairo_gstate_get_original_target:
365 * @gstate: a #cairo_gstate_t
366 *
367 * Return the original target with which @gstate was created. This
368 * function always returns the original target independent of any
369 * child target that may have been set with
370 * _cairo_gstate_redirect_target.
371 *
372 * Return value: the original target surface
373 **/
374 cairo_surface_t *
375 _cairo_gstate_get_original_target (cairo_gstate_t *gstate)
376 {
377 return gstate->original_target;
378 }
379
380 /**
381 * _cairo_gstate_get_clip:
382 * @gstate: a #cairo_gstate_t
383 *
384 * This space left intentionally blank.
385 *
386 * Return value: a pointer to the gstate's #cairo_clip_t structure.
387 **/
388 cairo_clip_t *
389 _cairo_gstate_get_clip (cairo_gstate_t *gstate)
390 {
391 return gstate->clip;
392 }
393
394 cairo_status_t
395 _cairo_gstate_set_source (cairo_gstate_t *gstate,
396 cairo_pattern_t *source)
397 {
398 if (source->status)
399 return source->status;
400
401 source = cairo_pattern_reference (source);
402 cairo_pattern_destroy (gstate->source);
403 gstate->source = source;
404 gstate->source_ctm_inverse = gstate->ctm_inverse;
405
406 return CAIRO_STATUS_SUCCESS;
407 }
408
409 cairo_pattern_t *
410 _cairo_gstate_get_source (cairo_gstate_t *gstate)
411 {
412 if (gstate->source == &_cairo_pattern_black.base) {
413 /* do not expose the static object to the user */
414 gstate->source = _cairo_pattern_create_solid (CAIRO_COLOR_BLACK);
415 }
416
417 return gstate->source;
418 }
419
420 cairo_status_t
421 _cairo_gstate_set_operator (cairo_gstate_t *gstate, cairo_operator_t op)
422 {
423 gstate->op = op;
424
425 return CAIRO_STATUS_SUCCESS;
426 }
427
428 cairo_operator_t
429 _cairo_gstate_get_operator (cairo_gstate_t *gstate)
430 {
431 return gstate->op;
432 }
433
434 cairo_status_t
435 _cairo_gstate_set_opacity (cairo_gstate_t *gstate, double op)
436 {
437 gstate->opacity = op;
438
439 return CAIRO_STATUS_SUCCESS;
440 }
441
442 double
443 _cairo_gstate_get_opacity (cairo_gstate_t *gstate)
444 {
445 return gstate->opacity;
446 }
447
448 cairo_status_t
449 _cairo_gstate_set_tolerance (cairo_gstate_t *gstate, double tolerance)
450 {
451 gstate->tolerance = tolerance;
452
453 return CAIRO_STATUS_SUCCESS;
454 }
455
456 double
457 _cairo_gstate_get_tolerance (cairo_gstate_t *gstate)
458 {
459 return gstate->tolerance;
460 }
461
462 cairo_status_t
463 _cairo_gstate_set_fill_rule (cairo_gstate_t *gstate, cairo_fill_rule_t fill_rule)
464 {
465 gstate->fill_rule = fill_rule;
466
467 return CAIRO_STATUS_SUCCESS;
468 }
469
470 cairo_fill_rule_t
471 _cairo_gstate_get_fill_rule (cairo_gstate_t *gstate)
472 {
473 return gstate->fill_rule;
474 }
475
476 cairo_status_t
477 _cairo_gstate_set_line_width (cairo_gstate_t *gstate, double width)
478 {
479 gstate->stroke_style.line_width = width;
480
481 return CAIRO_STATUS_SUCCESS;
482 }
483
484 double
485 _cairo_gstate_get_line_width (cairo_gstate_t *gstate)
486 {
487 return gstate->stroke_style.line_width;
488 }
489
490 cairo_status_t
491 _cairo_gstate_set_line_cap (cairo_gstate_t *gstate, cairo_line_cap_t line_cap)
492 {
493 gstate->stroke_style.line_cap = line_cap;
494
495 return CAIRO_STATUS_SUCCESS;
496 }
497
498 cairo_line_cap_t
499 _cairo_gstate_get_line_cap (cairo_gstate_t *gstate)
500 {
501 return gstate->stroke_style.line_cap;
502 }
503
504 cairo_status_t
505 _cairo_gstate_set_line_join (cairo_gstate_t *gstate, cairo_line_join_t line_join)
506 {
507 gstate->stroke_style.line_join = line_join;
508
509 return CAIRO_STATUS_SUCCESS;
510 }
511
512 cairo_line_join_t
513 _cairo_gstate_get_line_join (cairo_gstate_t *gstate)
514 {
515 return gstate->stroke_style.line_join;
516 }
517
518 cairo_status_t
519 _cairo_gstate_set_dash (cairo_gstate_t *gstate, const double *dash, int num_dashes, double offset)
520 {
521 double dash_total, on_total, off_total;
522 int i, j;
523
524 free (gstate->stroke_style.dash);
525
526 gstate->stroke_style.num_dashes = num_dashes;
527
528 if (gstate->stroke_style.num_dashes == 0) {
529 gstate->stroke_style.dash = NULL;
530 gstate->stroke_style.dash_offset = 0.0;
531 return CAIRO_STATUS_SUCCESS;
532 }
533
534 gstate->stroke_style.dash = _cairo_malloc_ab (gstate->stroke_style.num_dashes, sizeof (double));
535 if (unlikely (gstate->stroke_style.dash == NULL)) {
536 gstate->stroke_style.num_dashes = 0;
537 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
538 }
539
540 on_total = off_total = dash_total = 0.0;
541 for (i = j = 0; i < num_dashes; i++) {
542 if (dash[i] < 0)
543 return _cairo_error (CAIRO_STATUS_INVALID_DASH);
544
545 if (dash[i] == 0 && i > 0 && i < num_dashes - 1) {
546 if (dash[++i] < 0)
547 return _cairo_error (CAIRO_STATUS_INVALID_DASH);
548
549 gstate->stroke_style.dash[j-1] += dash[i];
550 gstate->stroke_style.num_dashes -= 2;
551 } else
552 gstate->stroke_style.dash[j++] = dash[i];
553
554 if (dash[i]) {
555 dash_total += dash[i];
556 if ((i & 1) == 0)
557 on_total += dash[i];
558 else
559 off_total += dash[i];
560 }
561 }
562
563 if (dash_total == 0.0)
564 return _cairo_error (CAIRO_STATUS_INVALID_DASH);
565
566 /* An odd dash value indicate symmetric repeating, so the total
567 * is twice as long. */
568 if (gstate->stroke_style.num_dashes & 1) {
569 dash_total *= 2;
570 on_total += off_total;
571 }
572
573 if (dash_total - on_total < CAIRO_FIXED_ERROR_DOUBLE) {
574 /* Degenerate dash -> solid line */
575 free (gstate->stroke_style.dash);
576 gstate->stroke_style.dash = NULL;
577 gstate->stroke_style.num_dashes = 0;
578 gstate->stroke_style.dash_offset = 0.0;
579 return CAIRO_STATUS_SUCCESS;
580 }
581
582 /* The dashing code doesn't like a negative offset or a big positive
583 * offset, so we compute an equivalent offset which is guaranteed to be
584 * positive and less than twice the pattern length. */
585 offset = fmod (offset, dash_total);
586 if (offset < 0.0)
587 offset += dash_total;
588 if (offset <= 0.0) /* Take care of -0 */
589 offset = 0.0;
590 gstate->stroke_style.dash_offset = offset;
591
592 return CAIRO_STATUS_SUCCESS;
593 }
594
595 void
596 _cairo_gstate_get_dash (cairo_gstate_t *gstate,
597 double *dashes,
598 int *num_dashes,
599 double *offset)
600 {
601 if (dashes) {
602 memcpy (dashes,
603 gstate->stroke_style.dash,
604 sizeof (double) * gstate->stroke_style.num_dashes);
605 }
606
607 if (num_dashes)
608 *num_dashes = gstate->stroke_style.num_dashes;
609
610 if (offset)
611 *offset = gstate->stroke_style.dash_offset;
612 }
613
614 cairo_status_t
615 _cairo_gstate_set_miter_limit (cairo_gstate_t *gstate, double limit)
616 {
617 gstate->stroke_style.miter_limit = limit;
618
619 return CAIRO_STATUS_SUCCESS;
620 }
621
622 double
623 _cairo_gstate_get_miter_limit (cairo_gstate_t *gstate)
624 {
625 return gstate->stroke_style.miter_limit;
626 }
627
628 void
629 _cairo_gstate_get_matrix (cairo_gstate_t *gstate, cairo_matrix_t *matrix)
630 {
631 *matrix = gstate->ctm;
632 }
633
634 cairo_status_t
635 _cairo_gstate_translate (cairo_gstate_t *gstate, double tx, double ty)
636 {
637 cairo_matrix_t tmp;
638
639 if (! ISFINITE (tx) || ! ISFINITE (ty))
640 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
641
642 _cairo_gstate_unset_scaled_font (gstate);
643
644 cairo_matrix_init_translate (&tmp, tx, ty);
645 cairo_matrix_multiply (&gstate->ctm, &tmp, &gstate->ctm);
646 gstate->is_identity = FALSE;
647
648 /* paranoid check against gradual numerical instability */
649 if (! _cairo_matrix_is_invertible (&gstate->ctm))
650 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
651
652 cairo_matrix_init_translate (&tmp, -tx, -ty);
653 cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);
654
655 return CAIRO_STATUS_SUCCESS;
656 }
657
658 cairo_status_t
659 _cairo_gstate_scale (cairo_gstate_t *gstate, double sx, double sy)
660 {
661 cairo_matrix_t tmp;
662
663 if (sx * sy == 0.) /* either sx or sy is 0, or det == 0 due to underflow */
664 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
665 if (! ISFINITE (sx) || ! ISFINITE (sy))
666 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
667
668 _cairo_gstate_unset_scaled_font (gstate);
669
670 cairo_matrix_init_scale (&tmp, sx, sy);
671 cairo_matrix_multiply (&gstate->ctm, &tmp, &gstate->ctm);
672 gstate->is_identity = FALSE;
673
674 /* paranoid check against gradual numerical instability */
675 if (! _cairo_matrix_is_invertible (&gstate->ctm))
676 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
677
678 cairo_matrix_init_scale (&tmp, 1/sx, 1/sy);
679 cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);
680
681 return CAIRO_STATUS_SUCCESS;
682 }
683
684 cairo_status_t
685 _cairo_gstate_rotate (cairo_gstate_t *gstate, double angle)
686 {
687 cairo_matrix_t tmp;
688
689 if (angle == 0.)
690 return CAIRO_STATUS_SUCCESS;
691
692 if (! ISFINITE (angle))
693 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
694
695 _cairo_gstate_unset_scaled_font (gstate);
696
697 cairo_matrix_init_rotate (&tmp, angle);
698 cairo_matrix_multiply (&gstate->ctm, &tmp, &gstate->ctm);
699 gstate->is_identity = FALSE;
700
701 /* paranoid check against gradual numerical instability */
702 if (! _cairo_matrix_is_invertible (&gstate->ctm))
703 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
704
705 cairo_matrix_init_rotate (&tmp, -angle);
706 cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);
707
708 return CAIRO_STATUS_SUCCESS;
709 }
710
711 cairo_status_t
712 _cairo_gstate_transform (cairo_gstate_t *gstate,
713 const cairo_matrix_t *matrix)
714 {
715 cairo_matrix_t tmp;
716 cairo_status_t status;
717
718 if (! _cairo_matrix_is_invertible (matrix))
719 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
720
721 if (_cairo_matrix_is_identity (matrix))
722 return CAIRO_STATUS_SUCCESS;
723
724 tmp = *matrix;
725 status = cairo_matrix_invert (&tmp);
726 if (unlikely (status))
727 return status;
728
729 _cairo_gstate_unset_scaled_font (gstate);
730
731 cairo_matrix_multiply (&gstate->ctm, matrix, &gstate->ctm);
732 cairo_matrix_multiply (&gstate->ctm_inverse, &gstate->ctm_inverse, &tmp);
733 gstate->is_identity = FALSE;
734
735 /* paranoid check against gradual numerical instability */
736 if (! _cairo_matrix_is_invertible (&gstate->ctm))
737 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
738
739 return CAIRO_STATUS_SUCCESS;
740 }
741
742 cairo_status_t
743 _cairo_gstate_set_matrix (cairo_gstate_t *gstate,
744 const cairo_matrix_t *matrix)
745 {
746 cairo_status_t status;
747
748 if (memcmp (matrix, &gstate->ctm, sizeof (cairo_matrix_t)) == 0)
749 return CAIRO_STATUS_SUCCESS;
750
751 if (! _cairo_matrix_is_invertible (matrix))
752 return _cairo_error (CAIRO_STATUS_INVALID_MATRIX);
753
754 if (_cairo_matrix_is_identity (matrix)) {
755 _cairo_gstate_identity_matrix (gstate);
756 return CAIRO_STATUS_SUCCESS;
757 }
758
759 _cairo_gstate_unset_scaled_font (gstate);
760
761 gstate->ctm = *matrix;
762 gstate->ctm_inverse = *matrix;
763 status = cairo_matrix_invert (&gstate->ctm_inverse);
764 assert (status == CAIRO_STATUS_SUCCESS);
765 gstate->is_identity = FALSE;
766
767 return CAIRO_STATUS_SUCCESS;
768 }
769
770 void
771 _cairo_gstate_identity_matrix (cairo_gstate_t *gstate)
772 {
773 if (_cairo_matrix_is_identity (&gstate->ctm))
774 return;
775
776 _cairo_gstate_unset_scaled_font (gstate);
777
778 cairo_matrix_init_identity (&gstate->ctm);
779 cairo_matrix_init_identity (&gstate->ctm_inverse);
780 gstate->is_identity = _cairo_matrix_is_identity (&gstate->target->device_transform);
781 }
782
783 void
784 _cairo_gstate_user_to_device (cairo_gstate_t *gstate, double *x, double *y)
785 {
786 cairo_matrix_transform_point (&gstate->ctm, x, y);
787 }
788
789 void
790 _cairo_gstate_user_to_device_distance (cairo_gstate_t *gstate,
791 double *dx, double *dy)
792 {
793 cairo_matrix_transform_distance (&gstate->ctm, dx, dy);
794 }
795
796 void
797 _cairo_gstate_device_to_user (cairo_gstate_t *gstate, double *x, double *y)
798 {
799 cairo_matrix_transform_point (&gstate->ctm_inverse, x, y);
800 }
801
802 void
803 _cairo_gstate_device_to_user_distance (cairo_gstate_t *gstate,
804 double *dx, double *dy)
805 {
806 cairo_matrix_transform_distance (&gstate->ctm_inverse, dx, dy);
807 }
808
809 void
810 _do_cairo_gstate_user_to_backend (cairo_gstate_t *gstate, double *x, double *y)
811 {
812 cairo_matrix_transform_point (&gstate->ctm, x, y);
813 cairo_matrix_transform_point (&gstate->target->device_transform, x, y);
814 }
815
816 void
817 _do_cairo_gstate_user_to_backend_distance (cairo_gstate_t *gstate, double *x, double *y)
818 {
819 cairo_matrix_transform_distance (&gstate->ctm, x, y);
820 cairo_matrix_transform_distance (&gstate->target->device_transform, x, y);
821 }
822
823 void
824 _do_cairo_gstate_backend_to_user (cairo_gstate_t *gstate, double *x, double *y)
825 {
826 cairo_matrix_transform_point (&gstate->target->device_transform_inverse, x, y);
827 cairo_matrix_transform_point (&gstate->ctm_inverse, x, y);
828 }
829
830 void
831 _do_cairo_gstate_backend_to_user_distance (cairo_gstate_t *gstate, double *x, double *y)
832 {
833 cairo_matrix_transform_distance (&gstate->target->device_transform_inverse, x, y);
834 cairo_matrix_transform_distance (&gstate->ctm_inverse, x, y);
835 }
836
837 void
838 _cairo_gstate_backend_to_user_rectangle (cairo_gstate_t *gstate,
839 double *x1, double *y1,
840 double *x2, double *y2,
841 cairo_bool_t *is_tight)
842 {
843 cairo_matrix_t matrix_inverse;
844
845 if (! _cairo_matrix_is_identity (&gstate->target->device_transform_inverse) ||
846 ! _cairo_matrix_is_identity (&gstate->ctm_inverse))
847 {
848 cairo_matrix_multiply (&matrix_inverse,
849 &gstate->target->device_transform_inverse,
850 &gstate->ctm_inverse);
851 _cairo_matrix_transform_bounding_box (&matrix_inverse,
852 x1, y1, x2, y2, is_tight);
853 }
854
855 else
856 {
857 if (is_tight)
858 *is_tight = TRUE;
859 }
860 }
861
862 /* XXX: NYI
863 cairo_status_t
864 _cairo_gstate_stroke_to_path (cairo_gstate_t *gstate)
865 {
866 cairo_status_t status;
867
868 _cairo_pen_init (&gstate);
869 return CAIRO_STATUS_SUCCESS;
870 }
871 */
872
873 void
874 _cairo_gstate_path_extents (cairo_gstate_t *gstate,
875 cairo_path_fixed_t *path,
876 double *x1, double *y1,
877 double *x2, double *y2)
878 {
879 cairo_box_t box;
880 double px1, py1, px2, py2;
881
882 if (_cairo_path_fixed_extents (path, &box)) {
883 px1 = _cairo_fixed_to_double (box.p1.x);
884 py1 = _cairo_fixed_to_double (box.p1.y);
885 px2 = _cairo_fixed_to_double (box.p2.x);
886 py2 = _cairo_fixed_to_double (box.p2.y);
887
888 _cairo_gstate_backend_to_user_rectangle (gstate,
889 &px1, &py1, &px2, &py2,
890 NULL);
891 } else {
892 px1 = 0.0;
893 py1 = 0.0;
894 px2 = 0.0;
895 py2 = 0.0;
896 }
897
898 if (x1)
899 *x1 = px1;
900 if (y1)
901 *y1 = py1;
902 if (x2)
903 *x2 = px2;
904 if (y2)
905 *y2 = py2;
906 }
907
908 static void
909 _cairo_gstate_copy_pattern (cairo_pattern_t *pattern,
910 const cairo_pattern_t *original)
911 {
912 /* First check if the we can replace the original with a much simpler
913 * pattern. For example, gradients that are uniform or just have a single
914 * stop can sometimes be replaced with a solid.
915 */
916
917 if (_cairo_pattern_is_clear (original)) {
918 _cairo_pattern_init_solid ((cairo_solid_pattern_t *) pattern,
919 CAIRO_COLOR_TRANSPARENT);
920 return;
921 }
922
923 if (original->type == CAIRO_PATTERN_TYPE_LINEAR ||
924 original->type == CAIRO_PATTERN_TYPE_RADIAL)
925 {
926 cairo_color_t color;
927 if (_cairo_gradient_pattern_is_solid ((cairo_gradient_pattern_t *) original,
928 NULL,
929 &color))
930 {
931 _cairo_pattern_init_solid ((cairo_solid_pattern_t *) pattern,
932 &color);
933 return;
934 }
935 }
936
937 _cairo_pattern_init_static_copy (pattern, original);
938 }
939
940 static void
941 _cairo_gstate_copy_transformed_pattern (cairo_gstate_t *gstate,
942 cairo_pattern_t *pattern,
943 const cairo_pattern_t *original,
944 const cairo_matrix_t *ctm_inverse)
945 {
946 _cairo_gstate_copy_pattern (pattern, original);
947
948 /* apply device_transform first so that it is transformed by ctm_inverse */
949 if (original->type == CAIRO_PATTERN_TYPE_SURFACE) {
950 cairo_surface_pattern_t *surface_pattern;
951 cairo_surface_t *surface;
952
953 surface_pattern = (cairo_surface_pattern_t *) original;
954 surface = surface_pattern->surface;
955
956 if (_cairo_surface_has_device_transform (surface))
957 _cairo_pattern_pretransform (pattern, &surface->device_transform);
958 }
959
960 if (! _cairo_matrix_is_identity (ctm_inverse))
961 _cairo_pattern_transform (pattern, ctm_inverse);
962
963 if (_cairo_surface_has_device_transform (gstate->target)) {
964 _cairo_pattern_transform (pattern,
965 &gstate->target->device_transform_inverse);
966 }
967 }
968
969 static void
970 _cairo_gstate_copy_transformed_source (cairo_gstate_t *gstate,
971 cairo_pattern_t *pattern)
972 {
973 _cairo_gstate_copy_transformed_pattern (gstate, pattern,
974 gstate->source,
975 &gstate->source_ctm_inverse);
976 }
977
978 static void
979 _cairo_gstate_copy_transformed_mask (cairo_gstate_t *gstate,
980 cairo_pattern_t *pattern,
981 cairo_pattern_t *mask)
982 {
983 _cairo_gstate_copy_transformed_pattern (gstate, pattern,
984 mask,
985 &gstate->ctm_inverse);
986 }
987
988 static cairo_operator_t
989 _reduce_op (cairo_gstate_t *gstate)
990 {
991 cairo_operator_t op;
992 const cairo_pattern_t *pattern;
993
994 op = gstate->op;
995 if (op != CAIRO_OPERATOR_SOURCE)
996 return op;
997
998 pattern = gstate->source;
999 if (pattern->type == CAIRO_PATTERN_TYPE_SOLID) {
1000 const cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) pattern;
1001 if (solid->color.alpha_short <= 0x00ff) {
1002 op = CAIRO_OPERATOR_CLEAR;
1003 } else if ((gstate->target->content & CAIRO_CONTENT_ALPHA) == 0) {
1004 if ((solid->color.red_short |
1005 solid->color.green_short |
1006 solid->color.blue_short) <= 0x00ff)
1007 {
1008 op = CAIRO_OPERATOR_CLEAR;
1009 }
1010 }
1011 } else if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
1012 const cairo_surface_pattern_t *surface = (cairo_surface_pattern_t *) pattern;
1013 if (surface->surface->is_clear &&
1014 surface->surface->content & CAIRO_CONTENT_ALPHA)
1015 {
1016 op = CAIRO_OPERATOR_CLEAR;
1017 }
1018 } else {
1019 const cairo_gradient_pattern_t *gradient = (cairo_gradient_pattern_t *) pattern;
1020 if (gradient->n_stops == 0)
1021 op = CAIRO_OPERATOR_CLEAR;
1022 }
1023
1024 return op;
1025 }
1026
1027 static cairo_status_t
1028 _cairo_gstate_get_pattern_status (const cairo_pattern_t *pattern)
1029 {
1030 if (unlikely (pattern->type == CAIRO_PATTERN_TYPE_MESH &&
1031 ((const cairo_mesh_pattern_t *) pattern)->current_patch))
1032 {
1033 /* If current patch != NULL, the pattern is under construction
1034 * and cannot be used as a source */
1035 return CAIRO_STATUS_INVALID_MESH_CONSTRUCTION;
1036 }
1037
1038 return pattern->status;
1039 }
1040
1041 cairo_status_t
1042 _cairo_gstate_paint (cairo_gstate_t *gstate)
1043 {
1044 cairo_pattern_union_t source_pattern;
1045 const cairo_pattern_t *pattern;
1046 cairo_status_t status;
1047 cairo_operator_t op;
1048
1049 status = _cairo_gstate_get_pattern_status (gstate->source);
1050 if (unlikely (status))
1051 return status;
1052
1053 if (gstate->op == CAIRO_OPERATOR_DEST)
1054 return CAIRO_STATUS_SUCCESS;
1055
1056 if (_cairo_clip_is_all_clipped (gstate->clip))
1057 return CAIRO_STATUS_SUCCESS;
1058
1059 op = _reduce_op (gstate);
1060 if (op == CAIRO_OPERATOR_CLEAR) {
1061 pattern = &_cairo_pattern_clear.base;
1062 } else {
1063 _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
1064 pattern = &source_pattern.base;
1065 }
1066
1067 return _cairo_surface_paint (gstate->target,
1068 op, pattern,
1069 gstate->clip);
1070 }
1071
1072 cairo_status_t
1073 _cairo_gstate_mask (cairo_gstate_t *gstate,
1074 cairo_pattern_t *mask)
1075 {
1076 cairo_pattern_union_t source_pattern, mask_pattern;
1077 const cairo_pattern_t *source;
1078 cairo_operator_t op;
1079 cairo_status_t status;
1080
1081 status = _cairo_gstate_get_pattern_status (mask);
1082 if (unlikely (status))
1083 return status;
1084
1085 status = _cairo_gstate_get_pattern_status (gstate->source);
1086 if (unlikely (status))
1087 return status;
1088
1089 if (gstate->op == CAIRO_OPERATOR_DEST)
1090 return CAIRO_STATUS_SUCCESS;
1091
1092 if (_cairo_clip_is_all_clipped (gstate->clip))
1093 return CAIRO_STATUS_SUCCESS;
1094
1095 assert (gstate->opacity == 1.0);
1096
1097 if (_cairo_pattern_is_opaque (mask, NULL))
1098 return _cairo_gstate_paint (gstate);
1099
1100 if (_cairo_pattern_is_clear (mask) &&
1101 _cairo_operator_bounded_by_mask (gstate->op))
1102 {
1103 return CAIRO_STATUS_SUCCESS;
1104 }
1105
1106 op = _reduce_op (gstate);
1107 if (op == CAIRO_OPERATOR_CLEAR) {
1108 source = &_cairo_pattern_clear.base;
1109 } else {
1110 _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
1111 source = &source_pattern.base;
1112 }
1113 _cairo_gstate_copy_transformed_mask (gstate, &mask_pattern.base, mask);
1114
1115 if (source->type == CAIRO_PATTERN_TYPE_SOLID &&
1116 mask_pattern.base.type == CAIRO_PATTERN_TYPE_SOLID &&
1117 _cairo_operator_bounded_by_source (op))
1118 {
1119 const cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) source;
1120 cairo_color_t combined;
1121
1122 if (mask_pattern.base.has_component_alpha) {
1123 #define M(R, A, B, c) R.c = A.c * B.c
1124 M(combined, solid->color, mask_pattern.solid.color, red);
1125 M(combined, solid->color, mask_pattern.solid.color, green);
1126 M(combined, solid->color, mask_pattern.solid.color, blue);
1127 M(combined, solid->color, mask_pattern.solid.color, alpha);
1128 #undef M
1129 } else {
1130 combined = solid->color;
1131 _cairo_color_multiply_alpha (&combined, mask_pattern.solid.color.alpha);
1132 }
1133
1134 _cairo_pattern_init_solid (&source_pattern.solid, &combined);
1135
1136 status = _cairo_surface_paint (gstate->target, op,
1137 &source_pattern.base,
1138 gstate->clip);
1139 }
1140 else
1141 {
1142 status = _cairo_surface_mask (gstate->target, op,
1143 source,
1144 &mask_pattern.base,
1145 gstate->clip);
1146 }
1147
1148 return status;
1149 }
1150
1151 cairo_status_t
1152 _cairo_gstate_stroke (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
1153 {
1154 cairo_pattern_union_t source_pattern;
1155 cairo_stroke_style_t style;
1156 double dash[2];
1157 cairo_status_t status;
1158 cairo_matrix_t aggregate_transform;
1159 cairo_matrix_t aggregate_transform_inverse;
1160
1161 status = _cairo_gstate_get_pattern_status (gstate->source);
1162 if (unlikely (status))
1163 return status;
1164
1165 if (gstate->op == CAIRO_OPERATOR_DEST)
1166 return CAIRO_STATUS_SUCCESS;
1167
1168 if (gstate->stroke_style.line_width <= 0.0)
1169 return CAIRO_STATUS_SUCCESS;
1170
1171 if (_cairo_clip_is_all_clipped (gstate->clip))
1172 return CAIRO_STATUS_SUCCESS;
1173
1174 assert (gstate->opacity == 1.0);
1175
1176 cairo_matrix_multiply (&aggregate_transform,
1177 &gstate->ctm,
1178 &gstate->target->device_transform);
1179 cairo_matrix_multiply (&aggregate_transform_inverse,
1180 &gstate->target->device_transform_inverse,
1181 &gstate->ctm_inverse);
1182
1183 memcpy (&style, &gstate->stroke_style, sizeof (gstate->stroke_style));
1184 if (_cairo_stroke_style_dash_can_approximate (&gstate->stroke_style, &aggregate_transform, gstate->tolerance)) {
1185 style.dash = dash;
1186 _cairo_stroke_style_dash_approximate (&gstate->stroke_style, &gstate->ctm, gstate->tolerance,
1187 &style.dash_offset,
1188 style.dash,
1189 &style.num_dashes);
1190 }
1191
1192 _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
1193
1194 return _cairo_surface_stroke (gstate->target,
1195 gstate->op,
1196 &source_pattern.base,
1197 path,
1198 &style,
1199 &aggregate_transform,
1200 &aggregate_transform_inverse,
1201 gstate->tolerance,
1202 gstate->antialias,
1203 gstate->clip);
1204 }
1205
1206 cairo_status_t
1207 _cairo_gstate_in_stroke (cairo_gstate_t *gstate,
1208 cairo_path_fixed_t *path,
1209 double x,
1210 double y,
1211 cairo_bool_t *inside_ret)
1212 {
1213 cairo_status_t status;
1214 cairo_rectangle_int_t extents;
1215 cairo_box_t limit;
1216 cairo_traps_t traps;
1217
1218 if (gstate->stroke_style.line_width <= 0.0) {
1219 *inside_ret = FALSE;
1220 return CAIRO_STATUS_SUCCESS;
1221 }
1222
1223 _cairo_gstate_user_to_backend (gstate, &x, &y);
1224
1225 /* Before we perform the expensive stroke analysis,
1226 * check whether the point is within the extents of the path.
1227 */
1228 _cairo_path_fixed_approximate_stroke_extents (path,
1229 &gstate->stroke_style,
1230 &gstate->ctm,
1231 &extents);
1232 if (x < extents.x || x > extents.x + extents.width ||
1233 y < extents.y || y > extents.y + extents.height)
1234 {
1235 *inside_ret = FALSE;
1236 return CAIRO_STATUS_SUCCESS;
1237 }
1238
1239 limit.p1.x = _cairo_fixed_from_double (x) - 1;
1240 limit.p1.y = _cairo_fixed_from_double (y) - 1;
1241 limit.p2.x = limit.p1.x + 2;
1242 limit.p2.y = limit.p1.y + 2;
1243
1244 _cairo_traps_init (&traps);
1245 _cairo_traps_limit (&traps, &limit, 1);
1246
1247 status = _cairo_path_fixed_stroke_polygon_to_traps (path,
1248 &gstate->stroke_style,
1249 &gstate->ctm,
1250 &gstate->ctm_inverse,
1251 gstate->tolerance,
1252 &traps);
1253 if (unlikely (status))
1254 goto BAIL;
1255
1256 *inside_ret = _cairo_traps_contain (&traps, x, y);
1257
1258 BAIL:
1259 _cairo_traps_fini (&traps);
1260
1261 return status;
1262 }
1263
1264 cairo_status_t
1265 _cairo_gstate_fill (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
1266 {
1267 cairo_status_t status;
1268
1269 status = _cairo_gstate_get_pattern_status (gstate->source);
1270 if (unlikely (status))
1271 return status;
1272
1273 if (gstate->op == CAIRO_OPERATOR_DEST)
1274 return CAIRO_STATUS_SUCCESS;
1275
1276 if (_cairo_clip_is_all_clipped (gstate->clip))
1277 return CAIRO_STATUS_SUCCESS;
1278
1279 assert (gstate->opacity == 1.0);
1280
1281 if (_cairo_path_fixed_fill_is_empty (path)) {
1282 if (_cairo_operator_bounded_by_mask (gstate->op))
1283 return CAIRO_STATUS_SUCCESS;
1284
1285 status = _cairo_surface_paint (gstate->target,
1286 CAIRO_OPERATOR_CLEAR,
1287 &_cairo_pattern_clear.base,
1288 gstate->clip);
1289 } else {
1290 cairo_pattern_union_t source_pattern;
1291 const cairo_pattern_t *pattern;
1292 cairo_operator_t op;
1293 cairo_rectangle_int_t extents;
1294 cairo_box_t box;
1295
1296 op = _reduce_op (gstate);
1297 if (op == CAIRO_OPERATOR_CLEAR) {
1298 pattern = &_cairo_pattern_clear.base;
1299 } else {
1300 _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
1301 pattern = &source_pattern.base;
1302 }
1303
1304 /* Toolkits often paint the entire background with a fill */
1305 if (_cairo_surface_get_extents (gstate->target, &extents) &&
1306 _cairo_path_fixed_is_box (path, &box) &&
1307 box.p1.x <= _cairo_fixed_from_int (extents.x) &&
1308 box.p1.y <= _cairo_fixed_from_int (extents.y) &&
1309 box.p2.x >= _cairo_fixed_from_int (extents.x + extents.width) &&
1310 box.p2.y >= _cairo_fixed_from_int (extents.y + extents.height))
1311 {
1312 status = _cairo_surface_paint (gstate->target, op, pattern,
1313 gstate->clip);
1314 }
1315 else
1316 {
1317 status = _cairo_surface_fill (gstate->target, op, pattern,
1318 path,
1319 gstate->fill_rule,
1320 gstate->tolerance,
1321 gstate->antialias,
1322 gstate->clip);
1323 }
1324 }
1325
1326 return status;
1327 }
1328
1329 cairo_bool_t
1330 _cairo_gstate_in_fill (cairo_gstate_t *gstate,
1331 cairo_path_fixed_t *path,
1332 double x,
1333 double y)
1334 {
1335 _cairo_gstate_user_to_backend (gstate, &x, &y);
1336
1337 return _cairo_path_fixed_in_fill (path,
1338 gstate->fill_rule,
1339 gstate->tolerance,
1340 x, y);
1341 }
1342
1343 cairo_bool_t
1344 _cairo_gstate_in_clip (cairo_gstate_t *gstate,
1345 double x,
1346 double y)
1347 {
1348 cairo_clip_t *clip = gstate->clip;
1349 int i;
1350
1351 if (_cairo_clip_is_all_clipped (clip))
1352 return FALSE;
1353
1354 if (clip == NULL)
1355 return TRUE;
1356
1357 _cairo_gstate_user_to_backend (gstate, &x, &y);
1358
1359 if (x < clip->extents.x ||
1360 x >= clip->extents.x + clip->extents.width ||
1361 y < clip->extents.y ||
1362 y >= clip->extents.y + clip->extents.height)
1363 {
1364 return FALSE;
1365 }
1366
1367 if (clip->num_boxes) {
1368 int fx, fy;
1369
1370 fx = _cairo_fixed_from_double (x);
1371 fy = _cairo_fixed_from_double (y);
1372 for (i = 0; i < clip->num_boxes; i++) {
1373 if (fx >= clip->boxes[i].p1.x && fx <= clip->boxes[i].p2.x &&
1374 fy >= clip->boxes[i].p1.y && fy <= clip->boxes[i].p2.y)
1375 break;
1376 }
1377 if (i == clip->num_boxes)
1378 return FALSE;
1379 }
1380
1381 if (clip->path) {
1382 cairo_clip_path_t *clip_path = clip->path;
1383 do {
1384 if (! _cairo_path_fixed_in_fill (&clip_path->path,
1385 clip_path->fill_rule,
1386 clip_path->tolerance,
1387 x, y))
1388 return FALSE;
1389 } while ((clip_path = clip_path->prev) != NULL);
1390 }
1391
1392 return TRUE;
1393 }
1394
1395 cairo_status_t
1396 _cairo_gstate_copy_page (cairo_gstate_t *gstate)
1397 {
1398 cairo_surface_copy_page (gstate->target);
1399 return cairo_surface_status (gstate->target);
1400 }
1401
1402 cairo_status_t
1403 _cairo_gstate_show_page (cairo_gstate_t *gstate)
1404 {
1405 cairo_surface_show_page (gstate->target);
1406 return cairo_surface_status (gstate->target);
1407 }
1408
1409 static void
1410 _cairo_gstate_extents_to_user_rectangle (cairo_gstate_t *gstate,
1411 const cairo_box_t *extents,
1412 double *x1, double *y1,
1413 double *x2, double *y2)
1414 {
1415 double px1, py1, px2, py2;
1416
1417 px1 = _cairo_fixed_to_double (extents->p1.x);
1418 py1 = _cairo_fixed_to_double (extents->p1.y);
1419 px2 = _cairo_fixed_to_double (extents->p2.x);
1420 py2 = _cairo_fixed_to_double (extents->p2.y);
1421
1422 _cairo_gstate_backend_to_user_rectangle (gstate,
1423 &px1, &py1, &px2, &py2,
1424 NULL);
1425 if (x1)
1426 *x1 = px1;
1427 if (y1)
1428 *y1 = py1;
1429 if (x2)
1430 *x2 = px2;
1431 if (y2)
1432 *y2 = py2;
1433 }
1434
1435 cairo_status_t
1436 _cairo_gstate_stroke_extents (cairo_gstate_t *gstate,
1437 cairo_path_fixed_t *path,
1438 double *x1, double *y1,
1439 double *x2, double *y2)
1440 {
1441 cairo_int_status_t status;
1442 cairo_box_t extents;
1443 cairo_bool_t empty;
1444
1445 if (x1)
1446 *x1 = 0.0;
1447 if (y1)
1448 *y1 = 0.0;
1449 if (x2)
1450 *x2 = 0.0;
1451 if (y2)
1452 *y2 = 0.0;
1453
1454 if (gstate->stroke_style.line_width <= 0.0)
1455 return CAIRO_STATUS_SUCCESS;
1456
1457 status = CAIRO_INT_STATUS_UNSUPPORTED;
1458 if (_cairo_path_fixed_stroke_is_rectilinear (path)) {
1459 cairo_boxes_t boxes;
1460
1461 _cairo_boxes_init (&boxes);
1462 status = _cairo_path_fixed_stroke_rectilinear_to_boxes (path,
1463 &gstate->stroke_style,
1464 &gstate->ctm,
1465 gstate->antialias,
1466 &boxes);
1467 empty = boxes.num_boxes == 0;
1468 if (! empty)
1469 _cairo_boxes_extents (&boxes, &extents);
1470 _cairo_boxes_fini (&boxes);
1471 }
1472
1473 if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
1474 cairo_polygon_t polygon;
1475
1476 _cairo_polygon_init (&polygon, NULL, 0);
1477 status = _cairo_path_fixed_stroke_to_polygon (path,
1478 &gstate->stroke_style,
1479 &gstate->ctm,
1480 &gstate->ctm_inverse,
1481 gstate->tolerance,
1482 &polygon);
1483 empty = polygon.num_edges == 0;
1484 if (! empty)
1485 extents = polygon.extents;
1486 _cairo_polygon_fini (&polygon);
1487 }
1488 if (! empty) {
1489 _cairo_gstate_extents_to_user_rectangle (gstate, &extents,
1490 x1, y1, x2, y2);
1491 }
1492
1493 return status;
1494 }
1495
1496 cairo_status_t
1497 _cairo_gstate_fill_extents (cairo_gstate_t *gstate,
1498 cairo_path_fixed_t *path,
1499 double *x1, double *y1,
1500 double *x2, double *y2)
1501 {
1502 cairo_status_t status;
1503 cairo_box_t extents;
1504 cairo_bool_t empty;
1505
1506 if (x1)
1507 *x1 = 0.0;
1508 if (y1)
1509 *y1 = 0.0;
1510 if (x2)
1511 *x2 = 0.0;
1512 if (y2)
1513 *y2 = 0.0;
1514
1515 if (_cairo_path_fixed_fill_is_empty (path))
1516 return CAIRO_STATUS_SUCCESS;
1517
1518 if (_cairo_path_fixed_fill_is_rectilinear (path)) {
1519 cairo_boxes_t boxes;
1520
1521 _cairo_boxes_init (&boxes);
1522 status = _cairo_path_fixed_fill_rectilinear_to_boxes (path,
1523 gstate->fill_rule,
1524 gstate->antialias,
1525 &boxes);
1526 empty = boxes.num_boxes == 0;
1527 if (! empty)
1528 _cairo_boxes_extents (&boxes, &extents);
1529
1530 _cairo_boxes_fini (&boxes);
1531 } else {
1532 cairo_traps_t traps;
1533
1534 _cairo_traps_init (&traps);
1535
1536 status = _cairo_path_fixed_fill_to_traps (path,
1537 gstate->fill_rule,
1538 gstate->tolerance,
1539 &traps);
1540 empty = traps.num_traps == 0;
1541 if (! empty)
1542 _cairo_traps_extents (&traps, &extents);
1543
1544 _cairo_traps_fini (&traps);
1545 }
1546
1547 if (! empty) {
1548 _cairo_gstate_extents_to_user_rectangle (gstate, &extents,
1549 x1, y1, x2, y2);
1550 }
1551
1552 return status;
1553 }
1554
1555 cairo_status_t
1556 _cairo_gstate_reset_clip (cairo_gstate_t *gstate)
1557 {
1558 _cairo_clip_destroy (gstate->clip);
1559 gstate->clip = NULL;
1560
1561 return CAIRO_STATUS_SUCCESS;
1562 }
1563
1564 cairo_status_t
1565 _cairo_gstate_clip (cairo_gstate_t *gstate, cairo_path_fixed_t *path)
1566 {
1567 gstate->clip =
1568 _cairo_clip_intersect_path (gstate->clip,
1569 path,
1570 gstate->fill_rule,
1571 gstate->tolerance,
1572 gstate->antialias);
1573 /* XXX */
1574 return CAIRO_STATUS_SUCCESS;
1575 }
1576
1577 static cairo_bool_t
1578 _cairo_gstate_int_clip_extents (cairo_gstate_t *gstate,
1579 cairo_rectangle_int_t *extents)
1580 {
1581 cairo_bool_t is_bounded;
1582
1583 is_bounded = _cairo_surface_get_extents (gstate->target, extents);
1584
1585 if (gstate->clip) {
1586 _cairo_rectangle_intersect (extents,
1587 _cairo_clip_get_extents (gstate->clip));
1588 is_bounded = TRUE;
1589 }
1590
1591 return is_bounded;
1592 }
1593
1594 cairo_bool_t
1595 _cairo_gstate_clip_extents (cairo_gstate_t *gstate,
1596 double *x1,
1597 double *y1,
1598 double *x2,
1599 double *y2)
1600 {
1601 cairo_rectangle_int_t extents;
1602 double px1, py1, px2, py2;
1603
1604 if (! _cairo_gstate_int_clip_extents (gstate, &extents))
1605 return FALSE;
1606
1607 px1 = extents.x;
1608 py1 = extents.y;
1609 px2 = extents.x + (int) extents.width;
1610 py2 = extents.y + (int) extents.height;
1611
1612 _cairo_gstate_backend_to_user_rectangle (gstate,
1613 &px1, &py1, &px2, &py2,
1614 NULL);
1615
1616 if (x1)
1617 *x1 = px1;
1618 if (y1)
1619 *y1 = py1;
1620 if (x2)
1621 *x2 = px2;
1622 if (y2)
1623 *y2 = py2;
1624
1625 return TRUE;
1626 }
1627
1628 cairo_rectangle_list_t*
1629 _cairo_gstate_copy_clip_rectangle_list (cairo_gstate_t *gstate)
1630 {
1631 cairo_rectangle_int_t extents;
1632 cairo_rectangle_list_t *list;
1633 cairo_clip_t *clip;
1634
1635 if (_cairo_surface_get_extents (gstate->target, &extents))
1636 clip = _cairo_clip_copy_intersect_rectangle (gstate->clip, &extents);
1637 else
1638 clip = gstate->clip;
1639
1640 list = _cairo_clip_copy_rectangle_list (clip, gstate);
1641
1642 if (clip != gstate->clip)
1643 _cairo_clip_destroy (clip);
1644
1645 return list;
1646 }
1647
1648 static void
1649 _cairo_gstate_unset_scaled_font (cairo_gstate_t *gstate)
1650 {
1651 if (gstate->scaled_font == NULL)
1652 return;
1653
1654 if (gstate->previous_scaled_font != NULL)
1655 cairo_scaled_font_destroy (gstate->previous_scaled_font);
1656
1657 gstate->previous_scaled_font = gstate->scaled_font;
1658 gstate->scaled_font = NULL;
1659 }
1660
1661 cairo_status_t
1662 _cairo_gstate_set_font_size (cairo_gstate_t *gstate,
1663 double size)
1664 {
1665 _cairo_gstate_unset_scaled_font (gstate);
1666
1667 cairo_matrix_init_scale (&gstate->font_matrix, size, size);
1668
1669 return CAIRO_STATUS_SUCCESS;
1670 }
1671
1672 cairo_status_t
1673 _cairo_gstate_set_font_matrix (cairo_gstate_t *gstate,
1674 const cairo_matrix_t *matrix)
1675 {
1676 if (memcmp (matrix, &gstate->font_matrix, sizeof (cairo_matrix_t)) == 0)
1677 return CAIRO_STATUS_SUCCESS;
1678
1679 _cairo_gstate_unset_scaled_font (gstate);
1680
1681 gstate->font_matrix = *matrix;
1682
1683 return CAIRO_STATUS_SUCCESS;
1684 }
1685
1686 void
1687 _cairo_gstate_get_font_matrix (cairo_gstate_t *gstate,
1688 cairo_matrix_t *matrix)
1689 {
1690 *matrix = gstate->font_matrix;
1691 }
1692
1693 void
1694 _cairo_gstate_set_font_options (cairo_gstate_t *gstate,
1695 const cairo_font_options_t *options)
1696 {
1697 if (memcmp (options, &gstate->font_options, sizeof (cairo_font_options_t)) == 0)
1698 return;
1699
1700 _cairo_gstate_unset_scaled_font (gstate);
1701
1702 _cairo_font_options_init_copy (&gstate->font_options, options);
1703 }
1704
1705 void
1706 _cairo_gstate_get_font_options (cairo_gstate_t *gstate,
1707 cairo_font_options_t *options)
1708 {
1709 *options = gstate->font_options;
1710 }
1711
1712 cairo_status_t
1713 _cairo_gstate_get_font_face (cairo_gstate_t *gstate,
1714 cairo_font_face_t **font_face)
1715 {
1716 cairo_status_t status;
1717
1718 status = _cairo_gstate_ensure_font_face (gstate);
1719 if (unlikely (status))
1720 return status;
1721
1722 *font_face = gstate->font_face;
1723
1724 return CAIRO_STATUS_SUCCESS;
1725 }
1726
1727 cairo_status_t
1728 _cairo_gstate_get_scaled_font (cairo_gstate_t *gstate,
1729 cairo_scaled_font_t **scaled_font)
1730 {
1731 cairo_status_t status;
1732
1733 status = _cairo_gstate_ensure_scaled_font (gstate);
1734 if (unlikely (status))
1735 return status;
1736
1737 *scaled_font = gstate->scaled_font;
1738
1739 return CAIRO_STATUS_SUCCESS;
1740 }
1741
1742 /*
1743 * Like everything else in this file, fonts involve Too Many Coordinate Spaces;
1744 * it is easy to get confused about what's going on.
1745 *
1746 * The user's view
1747 * ---------------
1748 *
1749 * Users ask for things in user space. When cairo starts, a user space unit
1750 * is about 1/96 inch, which is similar to (but importantly different from)
1751 * the normal "point" units most users think in terms of. When a user
1752 * selects a font, its scale is set to "one user unit". The user can then
1753 * independently scale the user coordinate system *or* the font matrix, in
1754 * order to adjust the rendered size of the font.
1755 *
1756 * Metrics are returned in user space, whether they are obtained from
1757 * the currently selected font in a #cairo_t or from a #cairo_scaled_font_t
1758 * which is a font specialized to a particular scale matrix, CTM, and target
1759 * surface.
1760 *
1761 * The font's view
1762 * ---------------
1763 *
1764 * Fonts are designed and stored (in say .ttf files) in "font space", which
1765 * describes an "EM Square" (a design tile) and has some abstract number
1766 * such as 1000, 1024, or 2048 units per "EM". This is basically an
1767 * uninteresting space for us, but we need to remember that it exists.
1768 *
1769 * Font resources (from libraries or operating systems) render themselves
1770 * to a particular device. Since they do not want to make most programmers
1771 * worry about the font design space, the scaling API is simplified to
1772 * involve just telling the font the required pixel size of the EM square
1773 * (that is, in device space).
1774 *
1775 *
1776 * Cairo's gstate view
1777 * -------------------
1778 *
1779 * In addition to the CTM and CTM inverse, we keep a matrix in the gstate
1780 * called the "font matrix" which describes the user's most recent
1781 * font-scaling or font-transforming request. This is kept in terms of an
1782 * abstract scale factor, composed with the CTM and used to set the font's
1783 * pixel size. So if the user asks to "scale the font by 12", the matrix
1784 * is:
1785 *
1786 * [ 12.0, 0.0, 0.0, 12.0, 0.0, 0.0 ]
1787 *
1788 * It is an affine matrix, like all cairo matrices, where its tx and ty
1789 * components are used to "nudging" fonts around and are handled in gstate
1790 * and then ignored by the "scaled-font" layer.
1791 *
1792 * In order to perform any action on a font, we must build an object
1793 * called a #cairo_font_scale_t; this contains the central 2x2 matrix
1794 * resulting from "font matrix * CTM" (sans the font matrix translation
1795 * components as stated in the previous paragraph).
1796 *
1797 * We pass this to the font when making requests of it, which causes it to
1798 * reply for a particular [user request, device] combination, under the CTM
1799 * (to accommodate the "zoom in" == "bigger fonts" issue above).
1800 *
1801 * The other terms in our communication with the font are therefore in
1802 * device space. When we ask it to perform text->glyph conversion, it will
1803 * produce a glyph string in device space. Glyph vectors we pass to it for
1804 * measuring or rendering should be in device space. The metrics which we
1805 * get back from the font will be in device space. The contents of the
1806 * global glyph image cache will be in device space.
1807 *
1808 *
1809 * Cairo's public view
1810 * -------------------
1811 *
1812 * Since the values entering and leaving via public API calls are in user
1813 * space, the gstate functions typically need to multiply arguments by the
1814 * CTM (for user-input glyph vectors), and return values by the CTM inverse
1815 * (for font responses such as metrics or glyph vectors).
1816 *
1817 */
1818
1819 static cairo_status_t
1820 _cairo_gstate_ensure_font_face (cairo_gstate_t *gstate)
1821 {
1822 cairo_font_face_t *font_face;
1823
1824 if (gstate->font_face != NULL)
1825 return gstate->font_face->status;
1826
1827
1828 font_face = cairo_toy_font_face_create (CAIRO_FONT_FAMILY_DEFAULT,
1829 CAIRO_FONT_SLANT_DEFAULT,
1830 CAIRO_FONT_WEIGHT_DEFAULT);
1831 if (font_face->status)
1832 return font_face->status;
1833
1834 gstate->font_face = font_face;
1835
1836 return CAIRO_STATUS_SUCCESS;
1837 }
1838
1839 static cairo_status_t
1840 _cairo_gstate_ensure_scaled_font (cairo_gstate_t *gstate)
1841 {
1842 cairo_status_t status;
1843 cairo_font_options_t options;
1844 cairo_scaled_font_t *scaled_font;
1845 cairo_matrix_t font_ctm;
1846
1847 if (gstate->scaled_font != NULL)
1848 return gstate->scaled_font->status;
1849
1850 status = _cairo_gstate_ensure_font_face (gstate);
1851 if (unlikely (status))
1852 return status;
1853
1854 cairo_surface_get_font_options (gstate->target, &options);
1855 cairo_font_options_merge (&options, &gstate->font_options);
1856
1857 cairo_matrix_multiply (&font_ctm,
1858 &gstate->ctm,
1859 &gstate->target->device_transform);
1860
1861 scaled_font = cairo_scaled_font_create (gstate->font_face,
1862 &gstate->font_matrix,
1863 &font_ctm,
1864 &options);
1865
1866 status = cairo_scaled_font_status (scaled_font);
1867 if (unlikely (status))
1868 return status;
1869
1870 gstate->scaled_font = scaled_font;
1871
1872 return CAIRO_STATUS_SUCCESS;
1873 }
1874
1875 cairo_status_t
1876 _cairo_gstate_get_font_extents (cairo_gstate_t *gstate,
1877 cairo_font_extents_t *extents)
1878 {
1879 cairo_status_t status = _cairo_gstate_ensure_scaled_font (gstate);
1880 if (unlikely (status))
1881 return status;
1882
1883 cairo_scaled_font_extents (gstate->scaled_font, extents);
1884
1885 return cairo_scaled_font_status (gstate->scaled_font);
1886 }
1887
1888 cairo_status_t
1889 _cairo_gstate_set_font_face (cairo_gstate_t *gstate,
1890 cairo_font_face_t *font_face)
1891 {
1892 if (font_face && font_face->status)
1893 return _cairo_error (font_face->status);
1894
1895 if (font_face == gstate->font_face)
1896 return CAIRO_STATUS_SUCCESS;
1897
1898 cairo_font_face_destroy (gstate->font_face);
1899 gstate->font_face = cairo_font_face_reference (font_face);
1900
1901 _cairo_gstate_unset_scaled_font (gstate);
1902
1903 return CAIRO_STATUS_SUCCESS;
1904 }
1905
1906 cairo_status_t
1907 _cairo_gstate_glyph_extents (cairo_gstate_t *gstate,
1908 const cairo_glyph_t *glyphs,
1909 int num_glyphs,
1910 cairo_text_extents_t *extents)
1911 {
1912 cairo_status_t status;
1913
1914 status = _cairo_gstate_ensure_scaled_font (gstate);
1915 if (unlikely (status))
1916 return status;
1917
1918 cairo_scaled_font_glyph_extents (gstate->scaled_font,
1919 glyphs, num_glyphs,
1920 extents);
1921
1922 return cairo_scaled_font_status (gstate->scaled_font);
1923 }
1924
1925 cairo_status_t
1926 _cairo_gstate_show_text_glyphs (cairo_gstate_t *gstate,
1927 const cairo_glyph_t *glyphs,
1928 int num_glyphs,
1929 cairo_glyph_text_info_t *info)
1930 {
1931 cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
1932 cairo_text_cluster_t stack_transformed_clusters[CAIRO_STACK_ARRAY_LENGTH (cairo_text_cluster_t)];
1933 cairo_pattern_union_t source_pattern;
1934 cairo_glyph_t *transformed_glyphs;
1935 const cairo_pattern_t *pattern;
1936 cairo_text_cluster_t *transformed_clusters;
1937 cairo_operator_t op;
1938 cairo_status_t status;
1939
1940 status = _cairo_gstate_get_pattern_status (gstate->source);
1941 if (unlikely (status))
1942 return status;
1943
1944 if (gstate->op == CAIRO_OPERATOR_DEST)
1945 return CAIRO_STATUS_SUCCESS;
1946
1947 if (_cairo_clip_is_all_clipped (gstate->clip))
1948 return CAIRO_STATUS_SUCCESS;
1949
1950 status = _cairo_gstate_ensure_scaled_font (gstate);
1951 if (unlikely (status))
1952 return status;
1953
1954 transformed_glyphs = stack_transformed_glyphs;
1955 transformed_clusters = stack_transformed_clusters;
1956
1957 if (num_glyphs > ARRAY_LENGTH (stack_transformed_glyphs)) {
1958 transformed_glyphs = cairo_glyph_allocate (num_glyphs);
1959 if (unlikely (transformed_glyphs == NULL))
1960 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
1961 }
1962
1963 if (info != NULL) {
1964 if (info->num_clusters > ARRAY_LENGTH (stack_transformed_clusters)) {
1965 transformed_clusters = cairo_text_cluster_allocate (info->num_clusters);
1966 if (unlikely (transformed_clusters == NULL)) {
1967 status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
1968 goto CLEANUP_GLYPHS;
1969 }
1970 }
1971
1972 _cairo_gstate_transform_glyphs_to_backend (gstate,
1973 glyphs, num_glyphs,
1974 info->clusters,
1975 info->num_clusters,
1976 info->cluster_flags,
1977 transformed_glyphs,
1978 &num_glyphs,
1979 transformed_clusters);
1980 } else {
1981 _cairo_gstate_transform_glyphs_to_backend (gstate,
1982 glyphs, num_glyphs,
1983 NULL, 0, 0,
1984 transformed_glyphs,
1985 &num_glyphs,
1986 NULL);
1987 }
1988
1989 if (num_glyphs == 0)
1990 goto CLEANUP_GLYPHS;
1991
1992 op = _reduce_op (gstate);
1993 if (op == CAIRO_OPERATOR_CLEAR) {
1994 pattern = &_cairo_pattern_clear.base;
1995 } else {
1996 _cairo_gstate_copy_transformed_source (gstate, &source_pattern.base);
1997 pattern = &source_pattern.base;
1998 }
1999
2000 /* For really huge font sizes, we can just do path;fill instead of
2001 * show_glyphs, as show_glyphs would put excess pressure on the cache,
2002 * and moreover, not all components below us correctly handle huge font
2003 * sizes. I wanted to set the limit at 256. But alas, seems like cairo's
2004 * rasterizer is something like ten times slower than freetype's for huge
2005 * sizes. So, no win just yet. For now, do it for insanely-huge sizes,
2006 * just to make sure we don't make anyone unhappy. When we get a really
2007 * fast rasterizer in cairo, we may want to readjust this.
2008 *
2009 * Needless to say, do this only if show_text_glyphs is not available. */
2010 if (cairo_surface_has_show_text_glyphs (gstate->target) ||
2011 _cairo_scaled_font_get_max_scale (gstate->scaled_font) <= 10240)
2012 {
2013
2014 if (info != NULL) {
2015 status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,
2016 info->utf8, info->utf8_len,
2017 transformed_glyphs, num_glyphs,
2018 transformed_clusters, info->num_clusters,
2019 info->cluster_flags,
2020 gstate->scaled_font,
2021 gstate->clip);
2022 } else {
2023 status = _cairo_surface_show_text_glyphs (gstate->target, op, pattern,
2024 NULL, 0,
2025 transformed_glyphs, num_glyphs,
2026 NULL, 0, 0,
2027 gstate->scaled_font,
2028 gstate->clip);
2029 }
2030 }
2031 else
2032 {
2033 cairo_path_fixed_t path;
2034
2035 _cairo_path_fixed_init (&path);
2036
2037 status = _cairo_scaled_font_glyph_path (gstate->scaled_font,
2038 transformed_glyphs, num_glyphs,
2039 &path);
2040
2041 if (status == CAIRO_STATUS_SUCCESS) {
2042 status = _cairo_surface_fill (gstate->target, op, pattern,
2043 &path,
2044 CAIRO_FILL_RULE_WINDING,
2045 gstate->tolerance,
2046 gstate->scaled_font->options.antialias,
2047 gstate->clip);
2048 }
2049
2050 _cairo_path_fixed_fini (&path);
2051 }
2052
2053 CLEANUP_GLYPHS:
2054 if (transformed_glyphs != stack_transformed_glyphs)
2055 cairo_glyph_free (transformed_glyphs);
2056 if (transformed_clusters != stack_transformed_clusters)
2057 cairo_text_cluster_free (transformed_clusters);
2058
2059 return status;
2060 }
2061
2062 cairo_status_t
2063 _cairo_gstate_glyph_path (cairo_gstate_t *gstate,
2064 const cairo_glyph_t *glyphs,
2065 int num_glyphs,
2066 cairo_path_fixed_t *path)
2067 {
2068 cairo_glyph_t stack_transformed_glyphs[CAIRO_STACK_ARRAY_LENGTH (cairo_glyph_t)];
2069 cairo_glyph_t *transformed_glyphs;
2070 cairo_status_t status;
2071
2072 status = _cairo_gstate_ensure_scaled_font (gstate);
2073 if (unlikely (status))
2074 return status;
2075
2076 if (num_glyphs < ARRAY_LENGTH (stack_transformed_glyphs)) {
2077 transformed_glyphs = stack_transformed_glyphs;
2078 } else {
2079 transformed_glyphs = cairo_glyph_allocate (num_glyphs);
2080 if (unlikely (transformed_glyphs == NULL))
2081 return _cairo_error (CAIRO_STATUS_NO_MEMORY);
2082 }
2083
2084 _cairo_gstate_transform_glyphs_to_backend (gstate,
2085 glyphs, num_glyphs,
2086 NULL, 0, 0,
2087 transformed_glyphs,
2088 &num_glyphs, NULL);
2089
2090 status = _cairo_scaled_font_glyph_path (gstate->scaled_font,
2091 transformed_glyphs, num_glyphs,
2092 path);
2093
2094 if (transformed_glyphs != stack_transformed_glyphs)
2095 cairo_glyph_free (transformed_glyphs);
2096
2097 return status;
2098 }
2099
2100 cairo_status_t
2101 _cairo_gstate_set_antialias (cairo_gstate_t *gstate,
2102 cairo_antialias_t antialias)
2103 {
2104 gstate->antialias = antialias;
2105
2106 return CAIRO_STATUS_SUCCESS;
2107 }
2108
2109 cairo_antialias_t
2110 _cairo_gstate_get_antialias (cairo_gstate_t *gstate)
2111 {
2112 return gstate->antialias;
2113 }
2114
2115 /**
2116 * _cairo_gstate_transform_glyphs_to_backend:
2117 * @gstate: a #cairo_gstate_t
2118 * @glyphs: the array of #cairo_glyph_t objects to be transformed
2119 * @num_glyphs: the number of elements in @glyphs
2120 * @transformed_glyphs: a pre-allocated array of at least @num_glyphs
2121 * #cairo_glyph_t objects
2122 * @num_transformed_glyphs: the number of elements in @transformed_glyphs
2123 * after dropping out of bounds glyphs, or %NULL if glyphs shouldn't be
2124 * dropped
2125 *
2126 * Transform an array of glyphs to backend space by first adding the offset
2127 * of the font matrix, then transforming from user space to backend space.
2128 * The result of the transformation is placed in @transformed_glyphs.
2129 *
2130 * This also uses information from the scaled font and the surface to
2131 * cull/drop glyphs that will not be visible.
2132 **/
2133 static void
2134 _cairo_gstate_transform_glyphs_to_backend (cairo_gstate_t *gstate,
2135 const cairo_glyph_t *glyphs,
2136 int num_glyphs,
2137 const cairo_text_cluster_t *clusters,
2138 int num_clusters,
2139 cairo_text_cluster_flags_t cluster_flags,
2140 cairo_glyph_t *transformed_glyphs,
2141 int *num_transformed_glyphs,
2142 cairo_text_cluster_t *transformed_clusters)
2143 {
2144 cairo_rectangle_int_t surface_extents;
2145 cairo_matrix_t *ctm = &gstate->ctm;
2146 cairo_matrix_t *font_matrix = &gstate->font_matrix;
2147 cairo_matrix_t *device_transform = &gstate->target->device_transform;
2148 cairo_bool_t drop = FALSE;
2149 double x1 = 0, x2 = 0, y1 = 0, y2 = 0;
2150 int i, j, k;
2151
2152 drop = TRUE;
2153 if (! _cairo_gstate_int_clip_extents (gstate, &surface_extents)) {
2154 drop = FALSE; /* unbounded surface */
2155 } else {
2156 double scale10 = 10 * _cairo_scaled_font_get_max_scale (gstate->scaled_font);
2157 if (surface_extents.width == 0 || surface_extents.height == 0) {
2158 /* No visible area. Don't draw anything */
2159 *num_transformed_glyphs = 0;
2160 return;
2161 }
2162 /* XXX We currently drop any glyphs that has its position outside
2163 * of the surface boundaries by a safety margin depending on the
2164 * font scale. This however can fail in extreme cases where the
2165 * font has really long swashes for example... We can correctly
2166 * handle that by looking the glyph up and using its device bbox
2167 * to device if it's going to be visible, but I'm not inclined to
2168 * do that now.
2169 */
2170 x1 = surface_extents.x - scale10;
2171 y1 = surface_extents.y - scale10;
2172 x2 = surface_extents.x + (int) surface_extents.width + scale10;
2173 y2 = surface_extents.y + (int) surface_extents.height + scale10;
2174 }
2175
2176 if (!drop)
2177 *num_transformed_glyphs = num_glyphs;
2178
2179 #define KEEP_GLYPH(glyph) (x1 <= glyph.x && glyph.x <= x2 && y1 <= glyph.y && glyph.y <= y2)
2180
2181 j = 0;
2182 if (_cairo_matrix_is_identity (ctm) &&
2183 _cairo_matrix_is_identity (device_transform) &&
2184 font_matrix->x0 == 0 && font_matrix->y0 == 0)
2185 {
2186 if (! drop) {
2187 memcpy (transformed_glyphs, glyphs,
2188 num_glyphs * sizeof (cairo_glyph_t));
2189 memcpy (transformed_clusters, clusters,
2190 num_clusters * sizeof (cairo_text_cluster_t));
2191 j = num_glyphs;
2192 } else if (num_clusters == 0) {
2193 for (i = 0; i < num_glyphs; i++) {
2194 transformed_glyphs[j].index = glyphs[i].index;
2195 transformed_glyphs[j].x = glyphs[i].x;
2196 transformed_glyphs[j].y = glyphs[i].y;
2197 if (KEEP_GLYPH (transformed_glyphs[j]))
2198 j++;
2199 }
2200 } else {
2201 const cairo_glyph_t *cur_glyph;
2202
2203 if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
2204 cur_glyph = glyphs + num_glyphs - 1;
2205 else
2206 cur_glyph = glyphs;
2207
2208 for (i = 0; i < num_clusters; i++) {
2209 cairo_bool_t cluster_visible = FALSE;
2210
2211 for (k = 0; k < clusters[i].num_glyphs; k++) {
2212 transformed_glyphs[j+k].index = cur_glyph->index;
2213 transformed_glyphs[j+k].x = cur_glyph->x;
2214 transformed_glyphs[j+k].y = cur_glyph->y;
2215 if (KEEP_GLYPH (transformed_glyphs[j+k]))
2216 cluster_visible = TRUE;
2217
2218 if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
2219 cur_glyph--;
2220 else
2221 cur_glyph++;
2222 }
2223
2224 transformed_clusters[i] = clusters[i];
2225 if (cluster_visible)
2226 j += k;
2227 else
2228 transformed_clusters[i].num_glyphs = 0;
2229 }
2230 }
2231 }
2232 else if (_cairo_matrix_is_translation (ctm) &&
2233 _cairo_matrix_is_translation (device_transform))
2234 {
2235 double tx = font_matrix->x0 + ctm->x0 + device_transform->x0;
2236 double ty = font_matrix->y0 + ctm->y0 + device_transform->y0;
2237
2238 if (! drop || num_clusters == 0) {
2239 for (i = 0; i < num_glyphs; i++) {
2240 transformed_glyphs[j].index = glyphs[i].index;
2241 transformed_glyphs[j].x = glyphs[i].x + tx;
2242 transformed_glyphs[j].y = glyphs[i].y + ty;
2243 if (!drop || KEEP_GLYPH (transformed_glyphs[j]))
2244 j++;
2245 }
2246 memcpy (transformed_clusters, clusters,
2247 num_clusters * sizeof (cairo_text_cluster_t));
2248 } else {
2249 const cairo_glyph_t *cur_glyph;
2250
2251 if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
2252 cur_glyph = glyphs + num_glyphs - 1;
2253 else
2254 cur_glyph = glyphs;
2255
2256 for (i = 0; i < num_clusters; i++) {
2257 cairo_bool_t cluster_visible = FALSE;
2258
2259 for (k = 0; k < clusters[i].num_glyphs; k++) {
2260 transformed_glyphs[j+k].index = cur_glyph->index;
2261 transformed_glyphs[j+k].x = cur_glyph->x + tx;
2262 transformed_glyphs[j+k].y = cur_glyph->y + ty;
2263 if (KEEP_GLYPH (transformed_glyphs[j+k]))
2264 cluster_visible = TRUE;
2265
2266 if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
2267 cur_glyph--;
2268 else
2269 cur_glyph++;
2270 }
2271
2272 transformed_clusters[i] = clusters[i];
2273 if (cluster_visible)
2274 j += k;
2275 else
2276 transformed_clusters[i].num_glyphs = 0;
2277 }
2278 }
2279 }
2280 else
2281 {
2282 cairo_matrix_t aggregate_transform;
2283
2284 cairo_matrix_init_translate (&aggregate_transform,
2285 gstate->font_matrix.x0,
2286 gstate->font_matrix.y0);
2287 cairo_matrix_multiply (&aggregate_transform,
2288 &aggregate_transform, ctm);
2289 cairo_matrix_multiply (&aggregate_transform,
2290 &aggregate_transform, device_transform);
2291
2292 if (! drop || num_clusters == 0) {
2293 for (i = 0; i < num_glyphs; i++) {
2294 transformed_glyphs[j] = glyphs[i];
2295 cairo_matrix_transform_point (&aggregate_transform,
2296 &transformed_glyphs[j].x,
2297 &transformed_glyphs[j].y);
2298 if (! drop || KEEP_GLYPH (transformed_glyphs[j]))
2299 j++;
2300 }
2301 memcpy (transformed_clusters, clusters,
2302 num_clusters * sizeof (cairo_text_cluster_t));
2303 } else {
2304 const cairo_glyph_t *cur_glyph;
2305
2306 if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
2307 cur_glyph = glyphs + num_glyphs - 1;
2308 else
2309 cur_glyph = glyphs;
2310
2311 for (i = 0; i < num_clusters; i++) {
2312 cairo_bool_t cluster_visible = FALSE;
2313 for (k = 0; k < clusters[i].num_glyphs; k++) {
2314 transformed_glyphs[j+k] = *cur_glyph;
2315 cairo_matrix_transform_point (&aggregate_transform,
2316 &transformed_glyphs[j+k].x,
2317 &transformed_glyphs[j+k].y);
2318 if (KEEP_GLYPH (transformed_glyphs[j+k]))
2319 cluster_visible = TRUE;
2320
2321 if (cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD)
2322 cur_glyph--;
2323 else
2324 cur_glyph++;
2325 }
2326
2327 transformed_clusters[i] = clusters[i];
2328 if (cluster_visible)
2329 j += k;
2330 else
2331 transformed_clusters[i].num_glyphs = 0;
2332 }
2333 }
2334 }
2335 *num_transformed_glyphs = j;
2336
2337 if (num_clusters != 0 && cluster_flags & CAIRO_TEXT_CLUSTER_FLAG_BACKWARD) {
2338 for (i = 0; i < --j; i++) {
2339 cairo_glyph_t tmp;
2340
2341 tmp = transformed_glyphs[i];
2342 transformed_glyphs[i] = transformed_glyphs[j];
2343 transformed_glyphs[j] = tmp;
2344 }
2345 }
2346 }
LuaTeX git mirror