Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */
  2. /* cairo - a vector graphics library with display and print output
  3.  *
  4.  * Copyright © 2002 University of Southern California
  5.  * Copyright © 2005 Red Hat, Inc.
  6.  * Copyright © 2011 Intel Corporation
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it either under the terms of the GNU Lesser General Public
  10.  * License version 2.1 as published by the Free Software Foundation
  11.  * (the "LGPL") or, at your option, under the terms of the Mozilla
  12.  * Public License Version 1.1 (the "MPL"). If you do not alter this
  13.  * notice, a recipient may use your version of this file under either
  14.  * the MPL or the LGPL.
  15.  *
  16.  * You should have received a copy of the LGPL along with this library
  17.  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
  19.  * You should have received a copy of the MPL along with this library
  20.  * in the file COPYING-MPL-1.1
  21.  *
  22.  * The contents of this file are subject to the Mozilla Public License
  23.  * Version 1.1 (the "License"); you may not use this file except in
  24.  * compliance with the License. You may obtain a copy of the License at
  25.  * http://www.mozilla.org/MPL/
  26.  *
  27.  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  28.  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  29.  * the specific language governing rights and limitations.
  30.  *
  31.  * The Original Code is the cairo graphics library.
  32.  *
  33.  * The Initial Developer of the Original Code is University of Southern
  34.  * California.
  35.  *
  36.  * Contributor(s):
  37.  *      Carl D. Worth <cworth@cworth.org>
  38.  *      Chris Wilson <chris@chris-wilson.co.uk>
  39.  */
  40.  
  41. #include "cairoint.h"
  42.  
  43. #include "cairo-private.h"
  44. #include "cairo-arc-private.h"
  45. #include "cairo-backend-private.h"
  46. #include "cairo-clip-inline.h"
  47. #include "cairo-default-context-private.h"
  48. #include "cairo-error-private.h"
  49. #include "cairo-freed-pool-private.h"
  50. #include "cairo-path-private.h"
  51. #include "cairo-pattern-private.h"
  52.  
  53. #define CAIRO_TOLERANCE_MINIMUM _cairo_fixed_to_double(1)
  54.  
  55. #if !defined(INFINITY)
  56. #define INFINITY HUGE_VAL
  57. #endif
  58.  
  59. static freed_pool_t context_pool;
  60.  
  61. void
  62. _cairo_default_context_reset_static_data (void)
  63. {
  64.     _freed_pool_reset (&context_pool);
  65. }
  66.  
  67. void
  68. _cairo_default_context_fini (cairo_default_context_t *cr)
  69. {
  70.     while (cr->gstate != &cr->gstate_tail[0]) {
  71.         if (_cairo_gstate_restore (&cr->gstate, &cr->gstate_freelist))
  72.             break;
  73.     }
  74.  
  75.     _cairo_gstate_fini (cr->gstate);
  76.     cr->gstate_freelist = cr->gstate_freelist->next; /* skip over tail[1] */
  77.     while (cr->gstate_freelist != NULL) {
  78.         cairo_gstate_t *gstate = cr->gstate_freelist;
  79.         cr->gstate_freelist = gstate->next;
  80.         free (gstate);
  81.     }
  82.  
  83.     _cairo_path_fixed_fini (cr->path);
  84.  
  85.     _cairo_fini (&cr->base);
  86. }
  87.  
  88. static void
  89. _cairo_default_context_destroy (void *abstract_cr)
  90. {
  91.     cairo_default_context_t *cr = abstract_cr;
  92.  
  93.     _cairo_default_context_fini (cr);
  94.  
  95.     /* mark the context as invalid to protect against misuse */
  96.     cr->base.status = CAIRO_STATUS_NULL_POINTER;
  97.     _freed_pool_put (&context_pool, cr);
  98. }
  99.  
  100. static cairo_surface_t *
  101. _cairo_default_context_get_original_target (void *abstract_cr)
  102. {
  103.     cairo_default_context_t *cr = abstract_cr;
  104.  
  105.     return _cairo_gstate_get_original_target (cr->gstate);
  106. }
  107.  
  108. static cairo_surface_t *
  109. _cairo_default_context_get_current_target (void *abstract_cr)
  110. {
  111.     cairo_default_context_t *cr = abstract_cr;
  112.  
  113.     return _cairo_gstate_get_target (cr->gstate);
  114. }
  115.  
  116. static cairo_status_t
  117. _cairo_default_context_save (void *abstract_cr)
  118. {
  119.     cairo_default_context_t *cr = abstract_cr;
  120.  
  121.     return _cairo_gstate_save (&cr->gstate, &cr->gstate_freelist);
  122. }
  123.  
  124. static cairo_status_t
  125. _cairo_default_context_restore (void *abstract_cr)
  126. {
  127.     cairo_default_context_t *cr = abstract_cr;
  128.  
  129.     if (unlikely (_cairo_gstate_is_group (cr->gstate)))
  130.         return _cairo_error (CAIRO_STATUS_INVALID_RESTORE);
  131.  
  132.     return _cairo_gstate_restore (&cr->gstate, &cr->gstate_freelist);
  133. }
  134.  
  135. static cairo_status_t
  136. _cairo_default_context_push_group (void *abstract_cr, cairo_content_t content)
  137. {
  138.     cairo_default_context_t *cr = abstract_cr;
  139.     cairo_surface_t *group_surface;
  140.     cairo_clip_t *clip;
  141.     cairo_status_t status;
  142.  
  143.     clip = _cairo_gstate_get_clip (cr->gstate);
  144.     if (_cairo_clip_is_all_clipped (clip)) {
  145.         group_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0);
  146.         status = group_surface->status;
  147.         if (unlikely (status))
  148.             goto bail;
  149.     } else {
  150.         cairo_surface_t *parent_surface;
  151.         cairo_rectangle_int_t extents;
  152.         cairo_bool_t bounded, is_empty;
  153.  
  154.         parent_surface = _cairo_gstate_get_target (cr->gstate);
  155.  
  156.         if (unlikely (parent_surface->status))
  157.             return parent_surface->status;
  158.         if (unlikely (parent_surface->finished))
  159.             return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
  160.  
  161.         /* Get the extents that we'll use in creating our new group surface */
  162.         bounded = _cairo_surface_get_extents (parent_surface, &extents);
  163.         if (clip)
  164.             /* XXX: This assignment just fixes a compiler warning? */
  165.             is_empty = _cairo_rectangle_intersect (&extents,
  166.                                                    _cairo_clip_get_extents (clip));
  167.  
  168.         if (!bounded) {
  169.             /* XXX: Generic solution? */
  170.             group_surface = cairo_recording_surface_create (content, NULL);
  171.             extents.x = extents.y = 0;
  172.         } else {
  173.             group_surface = _cairo_surface_create_similar_solid (parent_surface,
  174.                                                                  content,
  175.                                                                  extents.width,
  176.                                                                  extents.height,
  177.                                                                  CAIRO_COLOR_TRANSPARENT);
  178.         }
  179.         status = group_surface->status;
  180.         if (unlikely (status))
  181.             goto bail;
  182.  
  183.         /* Set device offsets on the new surface so that logically it appears at
  184.          * the same location on the parent surface -- when we pop_group this,
  185.          * the source pattern will get fixed up for the appropriate target surface
  186.          * device offsets, so we want to set our own surface offsets from /that/,
  187.          * and not from the device origin. */
  188.         cairo_surface_set_device_offset (group_surface,
  189.                                          parent_surface->device_transform.x0 - extents.x,
  190.                                          parent_surface->device_transform.y0 - extents.y);
  191.  
  192.         /* If we have a current path, we need to adjust it to compensate for
  193.          * the device offset just applied. */
  194.         _cairo_path_fixed_translate (cr->path,
  195.                                      _cairo_fixed_from_int (-extents.x),
  196.                                      _cairo_fixed_from_int (-extents.y));
  197.     }
  198.  
  199.     /* create a new gstate for the redirect */
  200.     status = _cairo_gstate_save (&cr->gstate, &cr->gstate_freelist);
  201.     if (unlikely (status))
  202.         goto bail;
  203.  
  204.     status = _cairo_gstate_redirect_target (cr->gstate, group_surface);
  205.  
  206. bail:
  207.     cairo_surface_destroy (group_surface);
  208.     return status;
  209. }
  210.  
  211. static cairo_pattern_t *
  212. _cairo_default_context_pop_group (void *abstract_cr)
  213. {
  214.     cairo_default_context_t *cr = abstract_cr;
  215.     cairo_surface_t *group_surface;
  216.     cairo_pattern_t *group_pattern;
  217.     cairo_matrix_t group_matrix, device_transform_matrix;
  218.     cairo_status_t status;
  219.  
  220.     /* Verify that we are at the right nesting level */
  221.     if (unlikely (! _cairo_gstate_is_group (cr->gstate)))
  222.         return _cairo_pattern_create_in_error (CAIRO_STATUS_INVALID_POP_GROUP);
  223.  
  224.     /* Get a reference to the active surface before restoring */
  225.     group_surface = _cairo_gstate_get_target (cr->gstate);
  226.     group_surface = cairo_surface_reference (group_surface);
  227.  
  228.     status = _cairo_gstate_restore (&cr->gstate, &cr->gstate_freelist);
  229.     assert (status == CAIRO_STATUS_SUCCESS);
  230.  
  231.     group_pattern = cairo_pattern_create_for_surface (group_surface);
  232.     status = group_pattern->status;
  233.     if (unlikely (status))
  234.         goto done;
  235.  
  236.     _cairo_gstate_get_matrix (cr->gstate, &group_matrix);
  237.     /* Transform by group_matrix centered around device_transform so that when
  238.      * we call _cairo_gstate_copy_transformed_pattern the result is a pattern
  239.      * with a matrix equivalent to the device_transform of group_surface. */
  240.     if (_cairo_surface_has_device_transform (group_surface)) {
  241.         cairo_pattern_set_matrix (group_pattern, &group_surface->device_transform);
  242.         _cairo_pattern_transform (group_pattern, &group_matrix);
  243.         _cairo_pattern_transform (group_pattern, &group_surface->device_transform_inverse);
  244.     } else {
  245.         cairo_pattern_set_matrix (group_pattern, &group_matrix);
  246.     }
  247.  
  248.     /* If we have a current path, we need to adjust it to compensate for
  249.      * the device offset just removed. */
  250.     cairo_matrix_multiply (&device_transform_matrix,
  251.                            &_cairo_gstate_get_target (cr->gstate)->device_transform,
  252.                            &group_surface->device_transform_inverse);
  253.     _cairo_path_fixed_transform (cr->path, &device_transform_matrix);
  254.  
  255. done:
  256.     cairo_surface_destroy (group_surface);
  257.  
  258.     return group_pattern;
  259. }
  260.  
  261. static cairo_status_t
  262. _cairo_default_context_set_source (void *abstract_cr,
  263.                                    cairo_pattern_t *source)
  264. {
  265.     cairo_default_context_t *cr = abstract_cr;
  266.  
  267.     return _cairo_gstate_set_source (cr->gstate, source);
  268. }
  269.  
  270. static cairo_bool_t
  271. _current_source_matches_solid (const cairo_pattern_t *pattern,
  272.                                double red,
  273.                                double green,
  274.                                double blue,
  275.                                double alpha)
  276. {
  277.     cairo_color_t color;
  278.  
  279.     if (pattern->type != CAIRO_PATTERN_TYPE_SOLID)
  280.         return FALSE;
  281.  
  282.     red   = _cairo_restrict_value (red,   0.0, 1.0);
  283.     green = _cairo_restrict_value (green, 0.0, 1.0);
  284.     blue  = _cairo_restrict_value (blue,  0.0, 1.0);
  285.     alpha = _cairo_restrict_value (alpha, 0.0, 1.0);
  286.  
  287.     _cairo_color_init_rgba (&color, red, green, blue, alpha);
  288.     return _cairo_color_equal (&color,
  289.                                &((cairo_solid_pattern_t *) pattern)->color);
  290. }
  291.  
  292. static cairo_status_t
  293. _cairo_default_context_set_source_rgba (void *abstract_cr, double red, double green, double blue, double alpha)
  294. {
  295.     cairo_default_context_t *cr = abstract_cr;
  296.     cairo_pattern_t *pattern;
  297.     cairo_status_t status;
  298.  
  299.     if (_current_source_matches_solid (cr->gstate->source,
  300.                                        red, green, blue, alpha))
  301.         return CAIRO_STATUS_SUCCESS;
  302.  
  303.     /* push the current pattern to the freed lists */
  304.     _cairo_default_context_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
  305.  
  306.     pattern = cairo_pattern_create_rgba (red, green, blue, alpha);
  307.     if (unlikely (pattern->status))
  308.         return pattern->status;
  309.  
  310.     status = _cairo_default_context_set_source (cr, pattern);
  311.     cairo_pattern_destroy (pattern);
  312.  
  313.     return status;
  314. }
  315.  
  316. static cairo_status_t
  317. _cairo_default_context_set_source_surface (void *abstract_cr,
  318.                                            cairo_surface_t *surface,
  319.                                            double          x,
  320.                                            double          y)
  321. {
  322.     cairo_default_context_t *cr = abstract_cr;
  323.     cairo_pattern_t *pattern;
  324.     cairo_matrix_t matrix;
  325.     cairo_status_t status;
  326.  
  327.     /* push the current pattern to the freed lists */
  328.     _cairo_default_context_set_source (cr, (cairo_pattern_t *) &_cairo_pattern_black);
  329.  
  330.     pattern = cairo_pattern_create_for_surface (surface);
  331.     if (unlikely (pattern->status))
  332.         return pattern->status;
  333.  
  334.     cairo_matrix_init_translate (&matrix, -x, -y);
  335.     cairo_pattern_set_matrix (pattern, &matrix);
  336.  
  337.     status = _cairo_default_context_set_source (cr, pattern);
  338.     cairo_pattern_destroy (pattern);
  339.  
  340.     return status;
  341. }
  342.  
  343. static cairo_pattern_t *
  344. _cairo_default_context_get_source (void *abstract_cr)
  345. {
  346.     cairo_default_context_t *cr = abstract_cr;
  347.  
  348.     return _cairo_gstate_get_source (cr->gstate);
  349. }
  350.  
  351. static cairo_status_t
  352. _cairo_default_context_set_tolerance (void *abstract_cr,
  353.                                       double tolerance)
  354. {
  355.     cairo_default_context_t *cr = abstract_cr;
  356.  
  357.     if (tolerance < CAIRO_TOLERANCE_MINIMUM)
  358.         tolerance = CAIRO_TOLERANCE_MINIMUM;
  359.  
  360.     return _cairo_gstate_set_tolerance (cr->gstate, tolerance);
  361. }
  362.  
  363. static cairo_status_t
  364. _cairo_default_context_set_operator (void *abstract_cr, cairo_operator_t op)
  365. {
  366.     cairo_default_context_t *cr = abstract_cr;
  367.  
  368.     return _cairo_gstate_set_operator (cr->gstate, op);
  369. }
  370.  
  371. static cairo_status_t
  372. _cairo_default_context_set_opacity (void *abstract_cr, double opacity)
  373. {
  374.     cairo_default_context_t *cr = abstract_cr;
  375.  
  376.     return _cairo_gstate_set_opacity (cr->gstate, opacity);
  377. }
  378.  
  379. static cairo_status_t
  380. _cairo_default_context_set_antialias (void *abstract_cr,
  381.                                       cairo_antialias_t antialias)
  382. {
  383.     cairo_default_context_t *cr = abstract_cr;
  384.  
  385.     return _cairo_gstate_set_antialias (cr->gstate, antialias);
  386. }
  387.  
  388. static cairo_status_t
  389. _cairo_default_context_set_fill_rule (void *abstract_cr,
  390.                                       cairo_fill_rule_t fill_rule)
  391. {
  392.     cairo_default_context_t *cr = abstract_cr;
  393.  
  394.     return _cairo_gstate_set_fill_rule (cr->gstate, fill_rule);
  395. }
  396.  
  397. static cairo_status_t
  398. _cairo_default_context_set_line_width (void *abstract_cr,
  399.                                        double line_width)
  400. {
  401.     cairo_default_context_t *cr = abstract_cr;
  402.  
  403.     return _cairo_gstate_set_line_width (cr->gstate, line_width);
  404. }
  405.  
  406. static cairo_status_t
  407. _cairo_default_context_set_line_cap (void *abstract_cr,
  408.                                      cairo_line_cap_t line_cap)
  409. {
  410.     cairo_default_context_t *cr = abstract_cr;
  411.  
  412.     return _cairo_gstate_set_line_cap (cr->gstate, line_cap);
  413. }
  414.  
  415. static cairo_status_t
  416. _cairo_default_context_set_line_join (void *abstract_cr,
  417.                                       cairo_line_join_t line_join)
  418. {
  419.     cairo_default_context_t *cr = abstract_cr;
  420.  
  421.     return _cairo_gstate_set_line_join (cr->gstate, line_join);
  422. }
  423.  
  424. static cairo_status_t
  425. _cairo_default_context_set_dash (void *abstract_cr,
  426.                                  const double *dashes,
  427.                                  int          num_dashes,
  428.                                  double       offset)
  429. {
  430.     cairo_default_context_t *cr = abstract_cr;
  431.  
  432.     return _cairo_gstate_set_dash (cr->gstate,
  433.                                    dashes, num_dashes, offset);
  434. }
  435.  
  436. static cairo_status_t
  437. _cairo_default_context_set_miter_limit (void *abstract_cr,
  438.                                         double limit)
  439. {
  440.     cairo_default_context_t *cr = abstract_cr;
  441.  
  442.     return _cairo_gstate_set_miter_limit (cr->gstate, limit);
  443. }
  444.  
  445. static cairo_antialias_t
  446. _cairo_default_context_get_antialias (void *abstract_cr)
  447. {
  448.     cairo_default_context_t *cr = abstract_cr;
  449.  
  450.     return _cairo_gstate_get_antialias (cr->gstate);
  451. }
  452.  
  453. static void
  454. _cairo_default_context_get_dash (void *abstract_cr,
  455.                                  double *dashes,
  456.                                  int *num_dashes,
  457.                                  double *offset)
  458. {
  459.     cairo_default_context_t *cr = abstract_cr;
  460.  
  461.     _cairo_gstate_get_dash (cr->gstate, dashes, num_dashes, offset);
  462. }
  463.  
  464. static cairo_fill_rule_t
  465. _cairo_default_context_get_fill_rule (void *abstract_cr)
  466. {
  467.     cairo_default_context_t *cr = abstract_cr;
  468.  
  469.     return _cairo_gstate_get_fill_rule (cr->gstate);
  470. }
  471.  
  472. static double
  473. _cairo_default_context_get_line_width (void *abstract_cr)
  474. {
  475.     cairo_default_context_t *cr = abstract_cr;
  476.  
  477.     return _cairo_gstate_get_line_width (cr->gstate);
  478. }
  479.  
  480. static cairo_line_cap_t
  481. _cairo_default_context_get_line_cap (void *abstract_cr)
  482. {
  483.     cairo_default_context_t *cr = abstract_cr;
  484.  
  485.     return _cairo_gstate_get_line_cap (cr->gstate);
  486. }
  487.  
  488. static cairo_line_join_t
  489. _cairo_default_context_get_line_join (void *abstract_cr)
  490. {
  491.     cairo_default_context_t *cr = abstract_cr;
  492.  
  493.     return _cairo_gstate_get_line_join (cr->gstate);
  494. }
  495.  
  496. static double
  497. _cairo_default_context_get_miter_limit (void *abstract_cr)
  498. {
  499.     cairo_default_context_t *cr = abstract_cr;
  500.  
  501.     return _cairo_gstate_get_miter_limit (cr->gstate);
  502. }
  503.  
  504. static cairo_operator_t
  505. _cairo_default_context_get_operator (void *abstract_cr)
  506. {
  507.     cairo_default_context_t *cr = abstract_cr;
  508.  
  509.     return _cairo_gstate_get_operator (cr->gstate);
  510. }
  511.  
  512. static double
  513. _cairo_default_context_get_opacity (void *abstract_cr)
  514. {
  515.     cairo_default_context_t *cr = abstract_cr;
  516.  
  517.     return _cairo_gstate_get_opacity (cr->gstate);
  518. }
  519.  
  520. static double
  521. _cairo_default_context_get_tolerance (void *abstract_cr)
  522. {
  523.     cairo_default_context_t *cr = abstract_cr;
  524.  
  525.     return _cairo_gstate_get_tolerance (cr->gstate);
  526. }
  527.  
  528.  
  529. /* Current tranformation matrix */
  530.  
  531. static cairo_status_t
  532. _cairo_default_context_translate (void *abstract_cr,
  533.                                   double tx,
  534.                                   double ty)
  535. {
  536.     cairo_default_context_t *cr = abstract_cr;
  537.  
  538.     return _cairo_gstate_translate (cr->gstate, tx, ty);
  539. }
  540.  
  541. static cairo_status_t
  542. _cairo_default_context_scale (void *abstract_cr,
  543.                               double sx,
  544.                               double sy)
  545. {
  546.     cairo_default_context_t *cr = abstract_cr;
  547.  
  548.     return _cairo_gstate_scale (cr->gstate, sx, sy);
  549. }
  550.  
  551. static cairo_status_t
  552. _cairo_default_context_rotate (void *abstract_cr,
  553.                                double theta)
  554. {
  555.     cairo_default_context_t *cr = abstract_cr;
  556.  
  557.     return _cairo_gstate_rotate (cr->gstate, theta);
  558. }
  559.  
  560. static cairo_status_t
  561. _cairo_default_context_transform (void *abstract_cr,
  562.                                   const cairo_matrix_t *matrix)
  563. {
  564.     cairo_default_context_t *cr = abstract_cr;
  565.  
  566.     return _cairo_gstate_transform (cr->gstate, matrix);
  567. }
  568.  
  569. static cairo_status_t
  570. _cairo_default_context_set_matrix (void *abstract_cr,
  571.                                    const cairo_matrix_t *matrix)
  572. {
  573.     cairo_default_context_t *cr = abstract_cr;
  574.  
  575.     return _cairo_gstate_set_matrix (cr->gstate, matrix);
  576. }
  577.  
  578. static cairo_status_t
  579. _cairo_default_context_set_identity_matrix (void *abstract_cr)
  580. {
  581.     cairo_default_context_t *cr = abstract_cr;
  582.  
  583.     _cairo_gstate_identity_matrix (cr->gstate);
  584.     return CAIRO_STATUS_SUCCESS;
  585. }
  586.  
  587. static void
  588. _cairo_default_context_get_matrix (void *abstract_cr,
  589.                                    cairo_matrix_t *matrix)
  590. {
  591.     cairo_default_context_t *cr = abstract_cr;
  592.  
  593.     _cairo_gstate_get_matrix (cr->gstate, matrix);
  594. }
  595.  
  596. static void
  597. _cairo_default_context_user_to_device (void *abstract_cr,
  598.                                        double *x,
  599.                                        double *y)
  600. {
  601.     cairo_default_context_t *cr = abstract_cr;
  602.  
  603.     _cairo_gstate_user_to_device (cr->gstate, x, y);
  604. }
  605.  
  606. static void
  607. _cairo_default_context_user_to_device_distance (void *abstract_cr, double *dx, double *dy)
  608. {
  609.     cairo_default_context_t *cr = abstract_cr;
  610.  
  611.     _cairo_gstate_user_to_device_distance (cr->gstate, dx, dy);
  612. }
  613.  
  614. static void
  615. _cairo_default_context_device_to_user (void *abstract_cr,
  616.                                        double *x,
  617.                                        double *y)
  618. {
  619.     cairo_default_context_t *cr = abstract_cr;
  620.  
  621.     _cairo_gstate_device_to_user (cr->gstate, x, y);
  622. }
  623.  
  624. static void
  625. _cairo_default_context_device_to_user_distance (void *abstract_cr,
  626.                                                 double *dx,
  627.                                                 double *dy)
  628. {
  629.     cairo_default_context_t *cr = abstract_cr;
  630.  
  631.     _cairo_gstate_device_to_user_distance (cr->gstate, dx, dy);
  632. }
  633.  
  634. static void
  635. _cairo_default_context_backend_to_user (void *abstract_cr,
  636.                                         double *x,
  637.                                         double *y)
  638. {
  639.     cairo_default_context_t *cr = abstract_cr;
  640.  
  641.     _cairo_gstate_backend_to_user (cr->gstate, x, y);
  642. }
  643.  
  644. static void
  645. _cairo_default_context_backend_to_user_distance (void *abstract_cr, double *dx, double *dy)
  646. {
  647.     cairo_default_context_t *cr = abstract_cr;
  648.  
  649.     _cairo_gstate_backend_to_user_distance (cr->gstate, dx, dy);
  650. }
  651.  
  652. static void
  653. _cairo_default_context_user_to_backend (void *abstract_cr,
  654.                                         double *x,
  655.                                         double *y)
  656. {
  657.     cairo_default_context_t *cr = abstract_cr;
  658.  
  659.     _cairo_gstate_user_to_backend (cr->gstate, x, y);
  660. }
  661.  
  662. static void
  663. _cairo_default_context_user_to_backend_distance (void *abstract_cr,
  664.                                                  double *dx,
  665.                                                  double *dy)
  666. {
  667.     cairo_default_context_t *cr = abstract_cr;
  668.  
  669.     _cairo_gstate_user_to_backend_distance (cr->gstate, dx, dy);
  670. }
  671.  
  672. /* Path constructor */
  673.  
  674. static cairo_status_t
  675. _cairo_default_context_new_path (void *abstract_cr)
  676. {
  677.     cairo_default_context_t *cr = abstract_cr;
  678.  
  679.     _cairo_path_fixed_fini (cr->path);
  680.     _cairo_path_fixed_init (cr->path);
  681.  
  682.     return CAIRO_STATUS_SUCCESS;
  683. }
  684.  
  685. static cairo_status_t
  686. _cairo_default_context_new_sub_path (void *abstract_cr)
  687. {
  688.     cairo_default_context_t *cr = abstract_cr;
  689.  
  690.     _cairo_path_fixed_new_sub_path (cr->path);
  691.  
  692.     return CAIRO_STATUS_SUCCESS;
  693. }
  694.  
  695. static cairo_status_t
  696. _cairo_default_context_move_to (void *abstract_cr, double x, double y)
  697. {
  698.     cairo_default_context_t *cr = abstract_cr;
  699.     cairo_fixed_t x_fixed, y_fixed;
  700.  
  701.     _cairo_gstate_user_to_backend (cr->gstate, &x, &y);
  702.     x_fixed = _cairo_fixed_from_double (x);
  703.     y_fixed = _cairo_fixed_from_double (y);
  704.  
  705.     return _cairo_path_fixed_move_to (cr->path, x_fixed, y_fixed);
  706. }
  707.  
  708. static cairo_status_t
  709. _cairo_default_context_line_to (void *abstract_cr, double x, double y)
  710. {
  711.     cairo_default_context_t *cr = abstract_cr;
  712.     cairo_fixed_t x_fixed, y_fixed;
  713.  
  714.     _cairo_gstate_user_to_backend (cr->gstate, &x, &y);
  715.     x_fixed = _cairo_fixed_from_double (x);
  716.     y_fixed = _cairo_fixed_from_double (y);
  717.  
  718.     return _cairo_path_fixed_line_to (cr->path, x_fixed, y_fixed);
  719. }
  720.  
  721. static cairo_status_t
  722. _cairo_default_context_curve_to (void *abstract_cr,
  723.                                  double x1, double y1,
  724.                                  double x2, double y2,
  725.                                  double x3, double y3)
  726. {
  727.     cairo_default_context_t *cr = abstract_cr;
  728.     cairo_fixed_t x1_fixed, y1_fixed;
  729.     cairo_fixed_t x2_fixed, y2_fixed;
  730.     cairo_fixed_t x3_fixed, y3_fixed;
  731.  
  732.     _cairo_gstate_user_to_backend (cr->gstate, &x1, &y1);
  733.     _cairo_gstate_user_to_backend (cr->gstate, &x2, &y2);
  734.     _cairo_gstate_user_to_backend (cr->gstate, &x3, &y3);
  735.  
  736.     x1_fixed = _cairo_fixed_from_double (x1);
  737.     y1_fixed = _cairo_fixed_from_double (y1);
  738.  
  739.     x2_fixed = _cairo_fixed_from_double (x2);
  740.     y2_fixed = _cairo_fixed_from_double (y2);
  741.  
  742.     x3_fixed = _cairo_fixed_from_double (x3);
  743.     y3_fixed = _cairo_fixed_from_double (y3);
  744.  
  745.     return _cairo_path_fixed_curve_to (cr->path,
  746.                                        x1_fixed, y1_fixed,
  747.                                        x2_fixed, y2_fixed,
  748.                                        x3_fixed, y3_fixed);
  749. }
  750.  
  751. static cairo_status_t
  752. _cairo_default_context_arc (void *abstract_cr,
  753.                             double xc, double yc, double radius,
  754.                             double angle1, double angle2,
  755.                             cairo_bool_t forward)
  756. {
  757.     cairo_default_context_t *cr = abstract_cr;
  758.     cairo_status_t status;
  759.  
  760.     /* Do nothing, successfully, if radius is <= 0 */
  761.     if (radius <= 0.0) {
  762.         cairo_fixed_t x_fixed, y_fixed;
  763.  
  764.         _cairo_gstate_user_to_backend (cr->gstate, &xc, &yc);
  765.         x_fixed = _cairo_fixed_from_double (xc);
  766.         y_fixed = _cairo_fixed_from_double (yc);
  767.         status = _cairo_path_fixed_line_to (cr->path, x_fixed, y_fixed);
  768.         if (unlikely (status))
  769.             return status;
  770.  
  771.         status = _cairo_path_fixed_line_to (cr->path, x_fixed, y_fixed);
  772.         if (unlikely (status))
  773.             return status;
  774.  
  775.         return CAIRO_STATUS_SUCCESS;
  776.     }
  777.  
  778.     status = _cairo_default_context_line_to (cr,
  779.                                              xc + radius * cos (angle1),
  780.                                              yc + radius * sin (angle1));
  781.  
  782.     if (unlikely (status))
  783.         return status;
  784.  
  785.     if (forward)
  786.         _cairo_arc_path (&cr->base, xc, yc, radius, angle1, angle2);
  787.     else
  788.         _cairo_arc_path_negative (&cr->base, xc, yc, radius, angle1, angle2);
  789.  
  790.     return CAIRO_STATUS_SUCCESS; /* any error will have already been set on cr */
  791. }
  792.  
  793. static cairo_status_t
  794. _cairo_default_context_rel_move_to (void *abstract_cr, double dx, double dy)
  795. {
  796.     cairo_default_context_t *cr = abstract_cr;
  797.     cairo_fixed_t dx_fixed, dy_fixed;
  798.  
  799.     _cairo_gstate_user_to_backend_distance (cr->gstate, &dx, &dy);
  800.  
  801.     dx_fixed = _cairo_fixed_from_double (dx);
  802.     dy_fixed = _cairo_fixed_from_double (dy);
  803.  
  804.     return _cairo_path_fixed_rel_move_to (cr->path, dx_fixed, dy_fixed);
  805. }
  806.  
  807. static cairo_status_t
  808. _cairo_default_context_rel_line_to (void *abstract_cr, double dx, double dy)
  809. {
  810.     cairo_default_context_t *cr = abstract_cr;
  811.     cairo_fixed_t dx_fixed, dy_fixed;
  812.  
  813.     _cairo_gstate_user_to_backend_distance (cr->gstate, &dx, &dy);
  814.  
  815.     dx_fixed = _cairo_fixed_from_double (dx);
  816.     dy_fixed = _cairo_fixed_from_double (dy);
  817.  
  818.     return _cairo_path_fixed_rel_line_to (cr->path, dx_fixed, dy_fixed);
  819. }
  820.  
  821.  
  822. static cairo_status_t
  823. _cairo_default_context_rel_curve_to (void *abstract_cr,
  824.                                      double dx1, double dy1,
  825.                                      double dx2, double dy2,
  826.                                      double dx3, double dy3)
  827. {
  828.     cairo_default_context_t *cr = abstract_cr;
  829.     cairo_fixed_t dx1_fixed, dy1_fixed;
  830.     cairo_fixed_t dx2_fixed, dy2_fixed;
  831.     cairo_fixed_t dx3_fixed, dy3_fixed;
  832.  
  833.     _cairo_gstate_user_to_backend_distance (cr->gstate, &dx1, &dy1);
  834.     _cairo_gstate_user_to_backend_distance (cr->gstate, &dx2, &dy2);
  835.     _cairo_gstate_user_to_backend_distance (cr->gstate, &dx3, &dy3);
  836.  
  837.     dx1_fixed = _cairo_fixed_from_double (dx1);
  838.     dy1_fixed = _cairo_fixed_from_double (dy1);
  839.  
  840.     dx2_fixed = _cairo_fixed_from_double (dx2);
  841.     dy2_fixed = _cairo_fixed_from_double (dy2);
  842.  
  843.     dx3_fixed = _cairo_fixed_from_double (dx3);
  844.     dy3_fixed = _cairo_fixed_from_double (dy3);
  845.  
  846.     return _cairo_path_fixed_rel_curve_to (cr->path,
  847.                                            dx1_fixed, dy1_fixed,
  848.                                            dx2_fixed, dy2_fixed,
  849.                                            dx3_fixed, dy3_fixed);
  850. }
  851.  
  852. static cairo_status_t
  853. _cairo_default_context_close_path (void *abstract_cr)
  854. {
  855.     cairo_default_context_t *cr = abstract_cr;
  856.  
  857.     return _cairo_path_fixed_close_path (cr->path);
  858. }
  859.  
  860. static cairo_status_t
  861. _cairo_default_context_rectangle (void *abstract_cr,
  862.                                   double x, double y,
  863.                                   double width, double height)
  864. {
  865.     cairo_default_context_t *cr = abstract_cr;
  866.     cairo_status_t status;
  867.  
  868.     status = _cairo_default_context_move_to (cr, x, y);
  869.     if (unlikely (status))
  870.         return status;
  871.  
  872.     status = _cairo_default_context_rel_line_to (cr, width, 0);
  873.     if (unlikely (status))
  874.         return status;
  875.  
  876.     status = _cairo_default_context_rel_line_to (cr, 0, height);
  877.     if (unlikely (status))
  878.         return status;
  879.  
  880.     status = _cairo_default_context_rel_line_to (cr, -width, 0);
  881.     if (unlikely (status))
  882.         return status;
  883.  
  884.     return _cairo_default_context_close_path (cr);
  885. }
  886.  
  887. static void
  888. _cairo_default_context_path_extents (void *abstract_cr,
  889.                                      double *x1,
  890.                                      double *y1,
  891.                                      double *x2,
  892.                                      double *y2)
  893. {
  894.     cairo_default_context_t *cr = abstract_cr;
  895.  
  896.     _cairo_gstate_path_extents (cr->gstate,
  897.                                 cr->path,
  898.                                 x1, y1, x2, y2);
  899. }
  900.  
  901. static cairo_bool_t
  902. _cairo_default_context_has_current_point (void *abstract_cr)
  903. {
  904.     cairo_default_context_t *cr = abstract_cr;
  905.  
  906.     return cr->path->has_current_point;
  907. }
  908.  
  909. static cairo_bool_t
  910. _cairo_default_context_get_current_point (void *abstract_cr,
  911.                                           double *x,
  912.                                           double *y)
  913. {
  914.     cairo_default_context_t *cr = abstract_cr;
  915.     cairo_fixed_t x_fixed, y_fixed;
  916.  
  917.     if (_cairo_path_fixed_get_current_point (cr->path, &x_fixed, &y_fixed))
  918.     {
  919.         *x = _cairo_fixed_to_double (x_fixed);
  920.         *y = _cairo_fixed_to_double (y_fixed);
  921.         _cairo_gstate_backend_to_user (cr->gstate, x, y);
  922.  
  923.         return TRUE;
  924.     }
  925.     else
  926.     {
  927.         return FALSE;
  928.     }
  929. }
  930.  
  931. static cairo_path_t *
  932. _cairo_default_context_copy_path (void *abstract_cr)
  933. {
  934.     cairo_default_context_t *cr = abstract_cr;
  935.  
  936.     return _cairo_path_create (cr->path, &cr->base);
  937. }
  938.  
  939. static cairo_path_t *
  940. _cairo_default_context_copy_path_flat (void *abstract_cr)
  941. {
  942.     cairo_default_context_t *cr = abstract_cr;
  943.  
  944.     return _cairo_path_create_flat (cr->path, &cr->base);
  945. }
  946.  
  947. static cairo_status_t
  948. _cairo_default_context_append_path (void *abstract_cr,
  949.                                     const cairo_path_t *path)
  950. {
  951.     cairo_default_context_t *cr = abstract_cr;
  952.  
  953.     return _cairo_path_append_to_context (path, &cr->base);
  954. }
  955.  
  956. static cairo_status_t
  957. _cairo_default_context_paint (void *abstract_cr)
  958. {
  959.     cairo_default_context_t *cr = abstract_cr;
  960.  
  961.     return _cairo_gstate_paint (cr->gstate);
  962. }
  963.  
  964. static cairo_status_t
  965. _cairo_default_context_paint_with_alpha (void *abstract_cr,
  966.                                          double alpha)
  967. {
  968.     cairo_default_context_t *cr = abstract_cr;
  969.     cairo_solid_pattern_t pattern;
  970.     cairo_status_t status;
  971.     cairo_color_t color;
  972.  
  973.     if (CAIRO_ALPHA_IS_OPAQUE (alpha))
  974.         return _cairo_gstate_paint (cr->gstate);
  975.  
  976.     if (CAIRO_ALPHA_IS_ZERO (alpha) &&
  977.         _cairo_operator_bounded_by_mask (cr->gstate->op)) {
  978.         return CAIRO_STATUS_SUCCESS;
  979.     }
  980.  
  981.     _cairo_color_init_rgba (&color, 0., 0., 0., alpha);
  982.     _cairo_pattern_init_solid (&pattern, &color);
  983.  
  984.     status = _cairo_gstate_mask (cr->gstate, &pattern.base);
  985.     _cairo_pattern_fini (&pattern.base);
  986.  
  987.     return status;
  988. }
  989.  
  990. static cairo_status_t
  991. _cairo_default_context_mask (void *abstract_cr,
  992.                              cairo_pattern_t *mask)
  993. {
  994.     cairo_default_context_t *cr = abstract_cr;
  995.  
  996.     return _cairo_gstate_mask (cr->gstate, mask);
  997. }
  998.  
  999. static cairo_status_t
  1000. _cairo_default_context_stroke_preserve (void *abstract_cr)
  1001. {
  1002.     cairo_default_context_t *cr = abstract_cr;
  1003.  
  1004.     return _cairo_gstate_stroke (cr->gstate, cr->path);
  1005. }
  1006.  
  1007. static cairo_status_t
  1008. _cairo_default_context_stroke (void *abstract_cr)
  1009. {
  1010.     cairo_default_context_t *cr = abstract_cr;
  1011.     cairo_status_t status;
  1012.  
  1013.     status = _cairo_gstate_stroke (cr->gstate, cr->path);
  1014.     if (unlikely (status))
  1015.         return status;
  1016.  
  1017.     return _cairo_default_context_new_path (cr);
  1018. }
  1019.  
  1020. static cairo_status_t
  1021. _cairo_default_context_in_stroke (void *abstract_cr,
  1022.                                   double x, double y,
  1023.                                   cairo_bool_t *inside)
  1024. {
  1025.     cairo_default_context_t *cr = abstract_cr;
  1026.  
  1027.     return _cairo_gstate_in_stroke (cr->gstate,
  1028.                                     cr->path,
  1029.                                     x, y,
  1030.                                     inside);
  1031. }
  1032.  
  1033. static cairo_status_t
  1034. _cairo_default_context_stroke_extents (void *abstract_cr,
  1035.                                        double *x1, double *y1, double *x2, double *y2)
  1036. {
  1037.     cairo_default_context_t *cr = abstract_cr;
  1038.  
  1039.     return _cairo_gstate_stroke_extents (cr->gstate,
  1040.                                          cr->path,
  1041.                                          x1, y1, x2, y2);
  1042. }
  1043.  
  1044. static cairo_status_t
  1045. _cairo_default_context_fill_preserve (void *abstract_cr)
  1046. {
  1047.     cairo_default_context_t *cr = abstract_cr;
  1048.  
  1049.     return _cairo_gstate_fill (cr->gstate, cr->path);
  1050. }
  1051.  
  1052. static cairo_status_t
  1053. _cairo_default_context_fill (void *abstract_cr)
  1054. {
  1055.     cairo_default_context_t *cr = abstract_cr;
  1056.     cairo_status_t status;
  1057.  
  1058.     status = _cairo_gstate_fill (cr->gstate, cr->path);
  1059.     if (unlikely (status))
  1060.         return status;
  1061.  
  1062.     return _cairo_default_context_new_path (cr);
  1063. }
  1064.  
  1065. static cairo_status_t
  1066. _cairo_default_context_in_fill (void *abstract_cr,
  1067.                                 double x, double y,
  1068.                                 cairo_bool_t *inside)
  1069. {
  1070.     cairo_default_context_t *cr = abstract_cr;
  1071.  
  1072.     *inside = _cairo_gstate_in_fill (cr->gstate,
  1073.                                      cr->path,
  1074.                                      x, y);
  1075.     return CAIRO_STATUS_SUCCESS;
  1076. }
  1077.  
  1078. static cairo_status_t
  1079. _cairo_default_context_fill_extents (void *abstract_cr,
  1080.                                      double *x1, double *y1, double *x2, double *y2)
  1081. {
  1082.     cairo_default_context_t *cr = abstract_cr;
  1083.  
  1084.     return _cairo_gstate_fill_extents (cr->gstate,
  1085.                                        cr->path,
  1086.                                        x1, y1, x2, y2);
  1087. }
  1088.  
  1089. static cairo_status_t
  1090. _cairo_default_context_clip_preserve (void *abstract_cr)
  1091. {
  1092.     cairo_default_context_t *cr = abstract_cr;
  1093.  
  1094.     return _cairo_gstate_clip (cr->gstate, cr->path);
  1095. }
  1096.  
  1097. static cairo_status_t
  1098. _cairo_default_context_clip (void *abstract_cr)
  1099. {
  1100.     cairo_default_context_t *cr = abstract_cr;
  1101.     cairo_status_t status;
  1102.  
  1103.     status = _cairo_gstate_clip (cr->gstate, cr->path);
  1104.     if (unlikely (status))
  1105.         return status;
  1106.  
  1107.     return _cairo_default_context_new_path (cr);
  1108. }
  1109.  
  1110. static cairo_status_t
  1111. _cairo_default_context_in_clip (void *abstract_cr,
  1112.                                 double x, double y,
  1113.                                 cairo_bool_t *inside)
  1114. {
  1115.     cairo_default_context_t *cr = abstract_cr;
  1116.  
  1117.     *inside = _cairo_gstate_in_clip (cr->gstate, x, y);
  1118.     return CAIRO_STATUS_SUCCESS;
  1119. }
  1120.  
  1121. static cairo_status_t
  1122. _cairo_default_context_reset_clip (void *abstract_cr)
  1123. {
  1124.     cairo_default_context_t *cr = abstract_cr;
  1125.  
  1126.     return _cairo_gstate_reset_clip (cr->gstate);
  1127. }
  1128.  
  1129. static cairo_status_t
  1130. _cairo_default_context_clip_extents (void *abstract_cr,
  1131.                                      double *x1, double *y1, double *x2, double *y2)
  1132. {
  1133.     cairo_default_context_t *cr = abstract_cr;
  1134.  
  1135.     if (! _cairo_gstate_clip_extents (cr->gstate, x1, y1, x2, y2)) {
  1136.         *x1 = -INFINITY;
  1137.         *y1 = -INFINITY;
  1138.         *x2 = +INFINITY;
  1139.         *y2 = +INFINITY;
  1140.     }
  1141.  
  1142.     return CAIRO_STATUS_SUCCESS;
  1143. }
  1144.  
  1145. static cairo_rectangle_list_t *
  1146. _cairo_default_context_copy_clip_rectangle_list (void *abstract_cr)
  1147. {
  1148.     cairo_default_context_t *cr = abstract_cr;
  1149.  
  1150.     return _cairo_gstate_copy_clip_rectangle_list (cr->gstate);
  1151. }
  1152.  
  1153. static cairo_status_t
  1154. _cairo_default_context_copy_page (void *abstract_cr)
  1155. {
  1156.     cairo_default_context_t *cr = abstract_cr;
  1157.  
  1158.     return _cairo_gstate_copy_page (cr->gstate);
  1159. }
  1160.  
  1161. static cairo_status_t
  1162. _cairo_default_context_show_page (void *abstract_cr)
  1163. {
  1164.     cairo_default_context_t *cr = abstract_cr;
  1165.  
  1166.     return _cairo_gstate_show_page (cr->gstate);
  1167. }
  1168.  
  1169. static cairo_status_t
  1170. _cairo_default_context_set_font_face (void *abstract_cr,
  1171.                                       cairo_font_face_t *font_face)
  1172. {
  1173.     cairo_default_context_t *cr = abstract_cr;
  1174.  
  1175.     return _cairo_gstate_set_font_face (cr->gstate, font_face);
  1176. }
  1177.  
  1178. static cairo_font_face_t *
  1179. _cairo_default_context_get_font_face (void *abstract_cr)
  1180. {
  1181.     cairo_default_context_t *cr = abstract_cr;
  1182.     cairo_font_face_t *font_face;
  1183.     cairo_status_t status;
  1184.  
  1185.     status = _cairo_gstate_get_font_face (cr->gstate, &font_face);
  1186.     if (unlikely (status)) {
  1187.         _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
  1188.         return (cairo_font_face_t *) &_cairo_font_face_nil;
  1189.     }
  1190.  
  1191.     return font_face;
  1192. }
  1193.  
  1194. static cairo_status_t
  1195. _cairo_default_context_font_extents (void *abstract_cr,
  1196.                                      cairo_font_extents_t *extents)
  1197. {
  1198.     cairo_default_context_t *cr = abstract_cr;
  1199.  
  1200.     return _cairo_gstate_get_font_extents (cr->gstate, extents);
  1201. }
  1202.  
  1203. static cairo_status_t
  1204. _cairo_default_context_set_font_size (void *abstract_cr,
  1205.                                       double size)
  1206. {
  1207.     cairo_default_context_t *cr = abstract_cr;
  1208.  
  1209.     return _cairo_gstate_set_font_size (cr->gstate, size);
  1210. }
  1211.  
  1212. static cairo_status_t
  1213. _cairo_default_context_set_font_matrix (void *abstract_cr,
  1214.                                         const cairo_matrix_t *matrix)
  1215. {
  1216.     cairo_default_context_t *cr = abstract_cr;
  1217.  
  1218.     return _cairo_gstate_set_font_matrix (cr->gstate, matrix);
  1219. }
  1220.  
  1221. static void
  1222. _cairo_default_context_get_font_matrix (void *abstract_cr,
  1223.                                         cairo_matrix_t *matrix)
  1224. {
  1225.     cairo_default_context_t *cr = abstract_cr;
  1226.  
  1227.     _cairo_gstate_get_font_matrix (cr->gstate, matrix);
  1228. }
  1229.  
  1230. static cairo_status_t
  1231. _cairo_default_context_set_font_options (void *abstract_cr,
  1232.                                          const cairo_font_options_t *options)
  1233. {
  1234.     cairo_default_context_t *cr = abstract_cr;
  1235.  
  1236.     _cairo_gstate_set_font_options (cr->gstate, options);
  1237.     return CAIRO_STATUS_SUCCESS;
  1238. }
  1239.  
  1240. static void
  1241. _cairo_default_context_get_font_options (void *abstract_cr,
  1242.                                          cairo_font_options_t *options)
  1243. {
  1244.     cairo_default_context_t *cr = abstract_cr;
  1245.  
  1246.     _cairo_gstate_get_font_options (cr->gstate, options);
  1247. }
  1248.  
  1249. static cairo_status_t
  1250. _cairo_default_context_set_scaled_font (void *abstract_cr,
  1251.                                         cairo_scaled_font_t *scaled_font)
  1252. {
  1253.     cairo_default_context_t *cr = abstract_cr;
  1254.     cairo_bool_t was_previous;
  1255.     cairo_status_t status;
  1256.  
  1257.     if (scaled_font == cr->gstate->scaled_font)
  1258.         return CAIRO_STATUS_SUCCESS;
  1259.  
  1260.     was_previous = scaled_font == cr->gstate->previous_scaled_font;
  1261.  
  1262.     status = _cairo_gstate_set_font_face (cr->gstate, scaled_font->font_face);
  1263.     if (unlikely (status))
  1264.         return status;
  1265.  
  1266.     status = _cairo_gstate_set_font_matrix (cr->gstate, &scaled_font->font_matrix);
  1267.     if (unlikely (status))
  1268.         return status;
  1269.  
  1270.     _cairo_gstate_set_font_options (cr->gstate, &scaled_font->options);
  1271.  
  1272.     if (was_previous)
  1273.         cr->gstate->scaled_font = cairo_scaled_font_reference (scaled_font);
  1274.  
  1275.     return CAIRO_STATUS_SUCCESS;
  1276. }
  1277.  
  1278. static cairo_scaled_font_t *
  1279. _cairo_default_context_get_scaled_font (void *abstract_cr)
  1280. {
  1281.     cairo_default_context_t *cr = abstract_cr;
  1282.     cairo_scaled_font_t *scaled_font;
  1283.     cairo_status_t status;
  1284.  
  1285.     status = _cairo_gstate_get_scaled_font (cr->gstate, &scaled_font);
  1286.     if (unlikely (status))
  1287.         return _cairo_scaled_font_create_in_error (status);
  1288.  
  1289.     return scaled_font;
  1290. }
  1291.  
  1292. static cairo_status_t
  1293. _cairo_default_context_glyphs (void *abstract_cr,
  1294.                                const cairo_glyph_t *glyphs,
  1295.                                int num_glyphs,
  1296.                                cairo_glyph_text_info_t *info)
  1297. {
  1298.     cairo_default_context_t *cr = abstract_cr;
  1299.  
  1300.     return _cairo_gstate_show_text_glyphs (cr->gstate, glyphs, num_glyphs, info);
  1301. }
  1302.  
  1303. static cairo_status_t
  1304. _cairo_default_context_glyph_path (void *abstract_cr,
  1305.                                    const cairo_glyph_t *glyphs,
  1306.                                    int num_glyphs)
  1307. {
  1308.     cairo_default_context_t *cr = abstract_cr;
  1309.  
  1310.     return _cairo_gstate_glyph_path (cr->gstate,
  1311.                                      glyphs, num_glyphs,
  1312.                                      cr->path);
  1313. }
  1314.  
  1315. static cairo_status_t
  1316. _cairo_default_context_glyph_extents (void                *abstract_cr,
  1317.                                       const cairo_glyph_t    *glyphs,
  1318.                                       int                    num_glyphs,
  1319.                                       cairo_text_extents_t   *extents)
  1320. {
  1321.     cairo_default_context_t *cr = abstract_cr;
  1322.  
  1323.     return _cairo_gstate_glyph_extents (cr->gstate, glyphs, num_glyphs, extents);
  1324. }
  1325.  
  1326. static const cairo_backend_t _cairo_default_context_backend = {
  1327.     CAIRO_TYPE_DEFAULT,
  1328.     _cairo_default_context_destroy,
  1329.  
  1330.     _cairo_default_context_get_original_target,
  1331.     _cairo_default_context_get_current_target,
  1332.  
  1333.     _cairo_default_context_save,
  1334.     _cairo_default_context_restore,
  1335.  
  1336.     _cairo_default_context_push_group,
  1337.     _cairo_default_context_pop_group,
  1338.  
  1339.     _cairo_default_context_set_source_rgba,
  1340.     _cairo_default_context_set_source_surface,
  1341.     _cairo_default_context_set_source,
  1342.     _cairo_default_context_get_source,
  1343.  
  1344.     _cairo_default_context_set_antialias,
  1345.     _cairo_default_context_set_dash,
  1346.     _cairo_default_context_set_fill_rule,
  1347.     _cairo_default_context_set_line_cap,
  1348.     _cairo_default_context_set_line_join,
  1349.     _cairo_default_context_set_line_width,
  1350.     _cairo_default_context_set_miter_limit,
  1351.     _cairo_default_context_set_opacity,
  1352.     _cairo_default_context_set_operator,
  1353.     _cairo_default_context_set_tolerance,
  1354.     _cairo_default_context_get_antialias,
  1355.     _cairo_default_context_get_dash,
  1356.     _cairo_default_context_get_fill_rule,
  1357.     _cairo_default_context_get_line_cap,
  1358.     _cairo_default_context_get_line_join,
  1359.     _cairo_default_context_get_line_width,
  1360.     _cairo_default_context_get_miter_limit,
  1361.     _cairo_default_context_get_opacity,
  1362.     _cairo_default_context_get_operator,
  1363.     _cairo_default_context_get_tolerance,
  1364.  
  1365.     _cairo_default_context_translate,
  1366.     _cairo_default_context_scale,
  1367.     _cairo_default_context_rotate,
  1368.     _cairo_default_context_transform,
  1369.     _cairo_default_context_set_matrix,
  1370.     _cairo_default_context_set_identity_matrix,
  1371.     _cairo_default_context_get_matrix,
  1372.  
  1373.     _cairo_default_context_user_to_device,
  1374.     _cairo_default_context_user_to_device_distance,
  1375.     _cairo_default_context_device_to_user,
  1376.     _cairo_default_context_device_to_user_distance,
  1377.  
  1378.     _cairo_default_context_user_to_backend,
  1379.     _cairo_default_context_user_to_backend_distance,
  1380.     _cairo_default_context_backend_to_user,
  1381.     _cairo_default_context_backend_to_user_distance,
  1382.  
  1383.     _cairo_default_context_new_path,
  1384.     _cairo_default_context_new_sub_path,
  1385.     _cairo_default_context_move_to,
  1386.     _cairo_default_context_rel_move_to,
  1387.     _cairo_default_context_line_to,
  1388.     _cairo_default_context_rel_line_to,
  1389.     _cairo_default_context_curve_to,
  1390.     _cairo_default_context_rel_curve_to,
  1391.     NULL, /* arc-to */
  1392.     NULL, /* rel-arc-to */
  1393.     _cairo_default_context_close_path,
  1394.     _cairo_default_context_arc,
  1395.     _cairo_default_context_rectangle,
  1396.     _cairo_default_context_path_extents,
  1397.     _cairo_default_context_has_current_point,
  1398.     _cairo_default_context_get_current_point,
  1399.     _cairo_default_context_copy_path,
  1400.     _cairo_default_context_copy_path_flat,
  1401.     _cairo_default_context_append_path,
  1402.  
  1403.     NULL, /* stroke-to-path */
  1404.  
  1405.     _cairo_default_context_clip,
  1406.     _cairo_default_context_clip_preserve,
  1407.     _cairo_default_context_in_clip,
  1408.     _cairo_default_context_clip_extents,
  1409.     _cairo_default_context_reset_clip,
  1410.     _cairo_default_context_copy_clip_rectangle_list,
  1411.  
  1412.     _cairo_default_context_paint,
  1413.     _cairo_default_context_paint_with_alpha,
  1414.     _cairo_default_context_mask,
  1415.  
  1416.     _cairo_default_context_stroke,
  1417.     _cairo_default_context_stroke_preserve,
  1418.     _cairo_default_context_in_stroke,
  1419.     _cairo_default_context_stroke_extents,
  1420.  
  1421.     _cairo_default_context_fill,
  1422.     _cairo_default_context_fill_preserve,
  1423.     _cairo_default_context_in_fill,
  1424.     _cairo_default_context_fill_extents,
  1425.  
  1426.     _cairo_default_context_set_font_face,
  1427.     _cairo_default_context_get_font_face,
  1428.     _cairo_default_context_set_font_size,
  1429.     _cairo_default_context_set_font_matrix,
  1430.     _cairo_default_context_get_font_matrix,
  1431.     _cairo_default_context_set_font_options,
  1432.     _cairo_default_context_get_font_options,
  1433.     _cairo_default_context_set_scaled_font,
  1434.     _cairo_default_context_get_scaled_font,
  1435.     _cairo_default_context_font_extents,
  1436.  
  1437.     _cairo_default_context_glyphs,
  1438.     _cairo_default_context_glyph_path,
  1439.     _cairo_default_context_glyph_extents,
  1440.  
  1441.     _cairo_default_context_copy_page,
  1442.     _cairo_default_context_show_page,
  1443. };
  1444.  
  1445. cairo_status_t
  1446. _cairo_default_context_init (cairo_default_context_t *cr, void *target)
  1447. {
  1448.     _cairo_init (&cr->base, &_cairo_default_context_backend);
  1449.     _cairo_path_fixed_init (cr->path);
  1450.  
  1451.     cr->gstate = &cr->gstate_tail[0];
  1452.     cr->gstate_freelist = &cr->gstate_tail[1];
  1453.     cr->gstate_tail[1].next = NULL;
  1454.  
  1455.     return _cairo_gstate_init (cr->gstate, target);
  1456. }
  1457.  
  1458. cairo_t *
  1459. _cairo_default_context_create (void *target)
  1460. {
  1461.     cairo_default_context_t *cr;
  1462.     cairo_status_t status;
  1463.  
  1464.     cr = _freed_pool_get (&context_pool);
  1465.     if (unlikely (cr == NULL)) {
  1466.         cr = malloc (sizeof (cairo_default_context_t));
  1467.         if (unlikely (cr == NULL))
  1468.             return _cairo_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
  1469.     }
  1470.  
  1471.     status = _cairo_default_context_init (cr, target);
  1472.     if (unlikely (status)) {
  1473.         _freed_pool_put (&context_pool, cr);
  1474.         return _cairo_create_in_error (status);
  1475.     }
  1476.  
  1477.     return &cr->base;
  1478. }
  1479.