Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /* cairo - a vector graphics library with display and print output
  2.  *
  3.  * Copyright © 2011 Intel Corporation.
  4.  *
  5.  * This library is free software; you can redistribute it and/or
  6.  * modify it either under the terms of the GNU Lesser General Public
  7.  * License version 2.1 as published by the Free Software Foundation
  8.  * (the "LGPL") or, at your option, under the terms of the Mozilla
  9.  * Public License Version 1.1 (the "MPL"). If you do not alter this
  10.  * notice, a recipient may use your version of this file under either
  11.  * the MPL or the LGPL.
  12.  *
  13.  * You should have received a copy of the LGPL along with this library
  14.  * in the file COPYING-LGPL-2.1; if not, write to the Free Software
  15.  * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
  16.  * You should have received a copy of the MPL along with this library
  17.  * in the file COPYING-MPL-1.1
  18.  *
  19.  * The contents of this file are subject to the Mozilla Public License
  20.  * Version 1.1 (the "License"); you may not use this file except in
  21.  * compliance with the License. You may obtain a copy of the License at
  22.  * http://www.mozilla.og/MPL/
  23.  *
  24.  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
  25.  * OF ANY KIND, either express or implied. See the LGPL or the MPL for
  26.  * the specific language governing rights and limitations.
  27.  *
  28.  * Contributor(s):
  29.  *      Robert Bragg <robert@linux.intel.com>
  30.  */
  31.  
  32. #include "cairoint.h"
  33. #include "cairo-cogl-utils-private.h"
  34.  
  35. #include <cogl/cogl.h>
  36. #include <glib.h>
  37.  
  38. static cairo_status_t
  39. _cogl_move_to (void                *closure,
  40.                const cairo_point_t *point)
  41. {
  42.     cogl_path_move_to (closure,
  43.                        _cairo_cogl_util_fixed_to_float (point->x),
  44.                        _cairo_cogl_util_fixed_to_float (point->y));
  45.     return CAIRO_STATUS_SUCCESS;
  46. }
  47.  
  48. static cairo_status_t
  49. _cogl_line_to (void                *closure,
  50.                const cairo_point_t *point)
  51. {
  52.     cogl_path_line_to (closure,
  53.                        _cairo_cogl_util_fixed_to_float (point->x),
  54.                        _cairo_cogl_util_fixed_to_float (point->y));
  55.     return CAIRO_STATUS_SUCCESS;
  56. }
  57.  
  58. static cairo_status_t
  59. _cogl_curve_to (void                *closure,
  60.                 const cairo_point_t *p0,
  61.                 const cairo_point_t *p1,
  62.                 const cairo_point_t *p2)
  63. {
  64.     cogl_path_curve_to (closure,
  65.                         _cairo_cogl_util_fixed_to_float (p0->x),
  66.                         _cairo_cogl_util_fixed_to_float (p0->y),
  67.                         _cairo_cogl_util_fixed_to_float (p1->x),
  68.                         _cairo_cogl_util_fixed_to_float (p1->y),
  69.                         _cairo_cogl_util_fixed_to_float (p2->x),
  70.                         _cairo_cogl_util_fixed_to_float (p2->y));
  71.     return CAIRO_STATUS_SUCCESS;
  72. }
  73.  
  74. static cairo_status_t
  75. _cogl_close_path (void *closure)
  76. {
  77.     cogl_path_close (closure);
  78.     return CAIRO_STATUS_SUCCESS;
  79. }
  80.  
  81. CoglPath *
  82. _cairo_cogl_util_path_from_cairo (const cairo_path_fixed_t *path,
  83.                                   cairo_fill_rule_t fill_rule,
  84.                                   float tolerance)
  85. {
  86.     CoglPath *cogl_path = cogl_path_new ();
  87.     cairo_status_t status;
  88.  
  89.     if (fill_rule == CAIRO_FILL_RULE_EVEN_ODD)
  90.         cogl_path_set_fill_rule (cogl_path, COGL_PATH_FILL_RULE_EVEN_ODD);
  91.     else
  92.         cogl_path_set_fill_rule (cogl_path, COGL_PATH_FILL_RULE_NON_ZERO);
  93.  
  94. #ifdef USE_CAIRO_PATH_FLATTENER
  95.     /* XXX: rely on cairo to do path flattening, since it seems Cogl's
  96.      * curve_to flattening is much slower */
  97.     status = _cairo_path_fixed_interpret_flat (path,
  98.                                                _cogl_move_to,
  99.                                                _cogl_line_to,
  100.                                                _cogl_close_path,
  101.                                                cogl_path,
  102.                                                tolerance);
  103. #else
  104.     status = _cairo_path_fixed_interpret (path,
  105.                                           _cogl_move_to,
  106.                                           _cogl_line_to,
  107.                                           _cogl_curve_to,
  108.                                           _cogl_close_path,
  109.                                           cogl_path);
  110. #endif
  111.  
  112.     assert (status == CAIRO_STATUS_SUCCESS);
  113.     return cogl_path;
  114. }
  115.  
  116. int
  117. _cairo_cogl_util_next_p2 (int a)
  118. {
  119.   int rval = 1;
  120.  
  121.   while (rval < a)
  122.     rval <<= 1;
  123.  
  124.   return rval;
  125. }
  126.  
  127.