Rev 1892 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1892 | serge | 1 | /* cairo - a vector graphics library with display and print output |
2 | * |
||
3 | * Copyright © 2005 Red Hat, Inc. |
||
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.org/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 | * The Original Code is the cairo graphics library. |
||
29 | * |
||
30 | * The Initial Developer of the Original Code is Red Hat, Inc. |
||
31 | * |
||
32 | * Contributor(s): |
||
33 | * Carl D. Worth |
||
34 | */ |
||
35 | |||
36 | #ifndef CAIRO_PATH_FIXED_PRIVATE_H |
||
37 | #define CAIRO_PATH_FIXED_PRIVATE_H |
||
38 | |||
39 | #include "cairo-types-private.h" |
||
40 | #include "cairo-compiler-private.h" |
||
41 | #include "cairo-list-private.h" |
||
42 | |||
43 | #define WATCH_PATH 0 |
||
44 | #if WATCH_PATH |
||
45 | #include |
||
46 | #endif |
||
47 | |||
48 | enum cairo_path_op { |
||
49 | CAIRO_PATH_OP_MOVE_TO = 0, |
||
50 | CAIRO_PATH_OP_LINE_TO = 1, |
||
51 | CAIRO_PATH_OP_CURVE_TO = 2, |
||
52 | CAIRO_PATH_OP_CLOSE_PATH = 3 |
||
53 | }; |
||
54 | |||
55 | /* we want to make sure a single byte is used for the enum */ |
||
56 | typedef char cairo_path_op_t; |
||
57 | |||
58 | /* make _cairo_path_fixed fit into ~512 bytes -- about 50 items */ |
||
59 | #define CAIRO_PATH_BUF_SIZE ((512 - sizeof (cairo_path_buf_t)) \ |
||
60 | / (2 * sizeof (cairo_point_t) + sizeof (cairo_path_op_t))) |
||
61 | |||
3959 | Serge | 62 | #define cairo_path_head(path__) (&(path__)->buf.base) |
63 | #define cairo_path_tail(path__) cairo_path_buf_prev (cairo_path_head (path__)) |
||
64 | |||
65 | #define cairo_path_buf_next(pos__) \ |
||
66 | cairo_list_entry ((pos__)->link.next, cairo_path_buf_t, link) |
||
67 | #define cairo_path_buf_prev(pos__) \ |
||
68 | cairo_list_entry ((pos__)->link.prev, cairo_path_buf_t, link) |
||
69 | |||
70 | #define cairo_path_foreach_buf_start(pos__, path__) \ |
||
71 | pos__ = cairo_path_head (path__); do |
||
72 | #define cairo_path_foreach_buf_end(pos__, path__) \ |
||
73 | while ((pos__ = cairo_path_buf_next (pos__)) != cairo_path_head (path__)) |
||
74 | |||
75 | |||
1892 | serge | 76 | typedef struct _cairo_path_buf { |
77 | cairo_list_t link; |
||
78 | unsigned int num_ops; |
||
79 | unsigned int size_ops; |
||
80 | unsigned int num_points; |
||
81 | unsigned int size_points; |
||
82 | |||
83 | cairo_path_op_t *op; |
||
84 | cairo_point_t *points; |
||
85 | } cairo_path_buf_t; |
||
86 | |||
87 | typedef struct _cairo_path_buf_fixed { |
||
88 | cairo_path_buf_t base; |
||
89 | |||
90 | cairo_path_op_t op[CAIRO_PATH_BUF_SIZE]; |
||
91 | cairo_point_t points[2 * CAIRO_PATH_BUF_SIZE]; |
||
92 | } cairo_path_buf_fixed_t; |
||
93 | |||
3959 | Serge | 94 | /* |
95 | NOTES: |
||
96 | has_curve_to => !stroke_is_rectilinear |
||
97 | fill_is_rectilinear => stroke_is_rectilinear |
||
98 | fill_is_empty => fill_is_rectilinear |
||
99 | fill_maybe_region => fill_is_rectilinear |
||
100 | */ |
||
1892 | serge | 101 | struct _cairo_path_fixed { |
102 | cairo_point_t last_move_point; |
||
103 | cairo_point_t current_point; |
||
104 | unsigned int has_current_point : 1; |
||
3959 | Serge | 105 | unsigned int needs_move_to : 1; |
106 | unsigned int has_extents : 1; |
||
1892 | serge | 107 | unsigned int has_curve_to : 1; |
3959 | Serge | 108 | unsigned int stroke_is_rectilinear : 1; |
109 | unsigned int fill_is_rectilinear : 1; |
||
110 | unsigned int fill_maybe_region : 1; |
||
111 | unsigned int fill_is_empty : 1; |
||
1892 | serge | 112 | |
113 | cairo_box_t extents; |
||
114 | |||
115 | cairo_path_buf_fixed_t buf; |
||
116 | }; |
||
117 | |||
118 | cairo_private void |
||
119 | _cairo_path_fixed_translate (cairo_path_fixed_t *path, |
||
120 | cairo_fixed_t offx, |
||
121 | cairo_fixed_t offy); |
||
122 | |||
123 | cairo_private cairo_status_t |
||
124 | _cairo_path_fixed_append (cairo_path_fixed_t *path, |
||
125 | const cairo_path_fixed_t *other, |
||
126 | cairo_fixed_t tx, |
||
127 | cairo_fixed_t ty); |
||
128 | |||
129 | cairo_private unsigned long |
||
130 | _cairo_path_fixed_hash (const cairo_path_fixed_t *path); |
||
131 | |||
132 | cairo_private unsigned long |
||
133 | _cairo_path_fixed_size (const cairo_path_fixed_t *path); |
||
134 | |||
135 | cairo_private cairo_bool_t |
||
136 | _cairo_path_fixed_equal (const cairo_path_fixed_t *a, |
||
137 | const cairo_path_fixed_t *b); |
||
138 | |||
139 | typedef struct _cairo_path_fixed_iter { |
||
140 | const cairo_path_buf_t *first; |
||
141 | const cairo_path_buf_t *buf; |
||
142 | unsigned int n_op; |
||
143 | unsigned int n_point; |
||
144 | } cairo_path_fixed_iter_t; |
||
145 | |||
146 | cairo_private void |
||
147 | _cairo_path_fixed_iter_init (cairo_path_fixed_iter_t *iter, |
||
148 | const cairo_path_fixed_t *path); |
||
149 | |||
150 | cairo_private cairo_bool_t |
||
151 | _cairo_path_fixed_iter_is_fill_box (cairo_path_fixed_iter_t *_iter, |
||
152 | cairo_box_t *box); |
||
153 | |||
154 | cairo_private cairo_bool_t |
||
155 | _cairo_path_fixed_iter_at_end (const cairo_path_fixed_iter_t *iter); |
||
156 | |||
157 | static inline cairo_bool_t |
||
158 | _cairo_path_fixed_fill_is_empty (const cairo_path_fixed_t *path) |
||
159 | { |
||
3959 | Serge | 160 | return path->fill_is_empty; |
1892 | serge | 161 | } |
162 | |||
163 | static inline cairo_bool_t |
||
3959 | Serge | 164 | _cairo_path_fixed_fill_is_rectilinear (const cairo_path_fixed_t *path) |
1892 | serge | 165 | { |
3959 | Serge | 166 | if (! path->fill_is_rectilinear) |
1892 | serge | 167 | return 0; |
168 | |||
3959 | Serge | 169 | if (! path->has_current_point || path->needs_move_to) |
1892 | serge | 170 | return 1; |
171 | |||
172 | /* check whether the implicit close preserves the rectilinear property */ |
||
173 | return path->current_point.x == path->last_move_point.x || |
||
174 | path->current_point.y == path->last_move_point.y; |
||
175 | } |
||
176 | |||
177 | static inline cairo_bool_t |
||
3959 | Serge | 178 | _cairo_path_fixed_stroke_is_rectilinear (const cairo_path_fixed_t *path) |
1892 | serge | 179 | { |
3959 | Serge | 180 | return path->stroke_is_rectilinear; |
1892 | serge | 181 | } |
182 | |||
3959 | Serge | 183 | static inline cairo_bool_t |
184 | _cairo_path_fixed_fill_maybe_region (const cairo_path_fixed_t *path) |
||
185 | { |
||
186 | if (! path->fill_maybe_region) |
||
187 | return 0; |
||
188 | |||
189 | if (! path->has_current_point || path->needs_move_to) |
||
190 | return 1; |
||
191 | |||
192 | /* check whether the implicit close preserves the rectilinear property |
||
193 | * (the integer point property is automatically preserved) |
||
194 | */ |
||
195 | return path->current_point.x == path->last_move_point.x || |
||
196 | path->current_point.y == path->last_move_point.y; |
||
197 | } |
||
198 | |||
199 | cairo_private cairo_bool_t |
||
200 | _cairo_path_fixed_is_stroke_box (const cairo_path_fixed_t *path, |
||
201 | cairo_box_t *box); |
||
202 | |||
203 | cairo_private cairo_bool_t |
||
204 | _cairo_path_fixed_is_simple_quad (const cairo_path_fixed_t *path); |
||
205 | |||
1892 | serge | 206 | #endif /* CAIRO_PATH_FIXED_PRIVATE_H */ |