1 /*
2 * Copyright © 2011 Google, Inc.
3 *
4 * This is part of HarfBuzz, a text shaping library.
5 *
6 * Permission is hereby granted, without written agreement and without
7 * license or royalty fees, to use, copy, modify, and distribute this
8 * software and its documentation for any purpose, provided that the
9 * above copyright notice and the following two paragraphs appear in
10 * all copies of this software.
11 *
12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16 * DAMAGE.
17 *
18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23 *
24 * Google Author(s): Behdad Esfahbod
25 */
26
27 #include "helper-cairo.hh"
28
29 #include <cairo-ft.h>
30 #include <hb-ft.h>
31
32 #include "helper-cairo-ansi.hh"
33 #ifdef CAIRO_HAS_SVG_SURFACE
34 # include <cairo-svg.h>
35 #endif
36 #ifdef CAIRO_HAS_PDF_SURFACE
37 # include <cairo-pdf.h>
38 #endif
39 #ifdef CAIRO_HAS_PS_SURFACE
40 # include <cairo-ps.h>
41 # if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1,6,0)
42 # define HAS_EPS 1
43
44 static cairo_surface_t *
_cairo_eps_surface_create_for_stream(cairo_write_func_t write_func,void * closure,double width,double height)45 _cairo_eps_surface_create_for_stream (cairo_write_func_t write_func,
46 void *closure,
47 double width,
48 double height)
49 {
50 cairo_surface_t *surface;
51
52 surface = cairo_ps_surface_create_for_stream (write_func, closure, width, height);
53 cairo_ps_surface_set_eps (surface, true);
54
55 return surface;
56 }
57
58 # else
59 # undef HAS_EPS
60 # endif
61 #endif
62
63 cairo_scaled_font_t *
helper_cairo_create_scaled_font(const font_options_t * font_opts,double font_size)64 helper_cairo_create_scaled_font (const font_options_t *font_opts,
65 double font_size)
66 {
67 hb_font_t *font = hb_font_reference (font_opts->get_font ());
68
69 cairo_font_face_t *cairo_face;
70 FT_Face ft_face = hb_ft_font_get_face (font);
71 if (!ft_face)
72 /* This allows us to get some boxes at least... */
73 cairo_face = cairo_toy_font_face_create ("@cairo:sans",
74 CAIRO_FONT_SLANT_NORMAL,
75 CAIRO_FONT_WEIGHT_NORMAL);
76 else
77 cairo_face = cairo_ft_font_face_create_for_ft_face (ft_face, 0);
78 cairo_matrix_t ctm, font_matrix;
79 cairo_font_options_t *font_options;
80
81 cairo_matrix_init_identity (&ctm);
82 cairo_matrix_init_scale (&font_matrix,
83 font_size, font_size);
84 font_options = cairo_font_options_create ();
85 cairo_font_options_set_hint_style (font_options, CAIRO_HINT_STYLE_NONE);
86 cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
87
88 cairo_scaled_font_t *scaled_font = cairo_scaled_font_create (cairo_face,
89 &font_matrix,
90 &ctm,
91 font_options);
92
93 cairo_font_options_destroy (font_options);
94 cairo_font_face_destroy (cairo_face);
95
96 static cairo_user_data_key_t key;
97 if (cairo_scaled_font_set_user_data (scaled_font,
98 &key,
99 (void *) font,
100 (cairo_destroy_func_t) hb_font_destroy))
101 hb_font_destroy (font);
102
103 return scaled_font;
104 }
105
106
107 struct finalize_closure_t {
108 void (*callback)(finalize_closure_t *);
109 cairo_surface_t *surface;
110 cairo_write_func_t write_func;
111 void *closure;
112 };
113 static cairo_user_data_key_t finalize_closure_key;
114
115
116 static void
finalize_ansi(finalize_closure_t * closure)117 finalize_ansi (finalize_closure_t *closure)
118 {
119 cairo_status_t status;
120 status = helper_cairo_surface_write_to_ansi_stream (closure->surface,
121 closure->write_func,
122 closure->closure);
123 if (status != CAIRO_STATUS_SUCCESS)
124 fail (false, "Failed to write output: %s",
125 cairo_status_to_string (status));
126 }
127
128 static cairo_surface_t *
_cairo_ansi_surface_create_for_stream(cairo_write_func_t write_func,void * closure,double width,double height,cairo_content_t content)129 _cairo_ansi_surface_create_for_stream (cairo_write_func_t write_func,
130 void *closure,
131 double width,
132 double height,
133 cairo_content_t content)
134 {
135 cairo_surface_t *surface;
136 int w = ceil (width);
137 int h = ceil (height);
138
139 switch (content) {
140 case CAIRO_CONTENT_ALPHA:
141 surface = cairo_image_surface_create (CAIRO_FORMAT_A8, w, h);
142 break;
143 default:
144 case CAIRO_CONTENT_COLOR:
145 surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
146 break;
147 case CAIRO_CONTENT_COLOR_ALPHA:
148 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
149 break;
150 }
151 cairo_status_t status = cairo_surface_status (surface);
152 if (status != CAIRO_STATUS_SUCCESS)
153 fail (false, "Failed to create cairo surface: %s",
154 cairo_status_to_string (status));
155
156 finalize_closure_t *ansi_closure = g_new0 (finalize_closure_t, 1);
157 ansi_closure->callback = finalize_ansi;
158 ansi_closure->surface = surface;
159 ansi_closure->write_func = write_func;
160 ansi_closure->closure = closure;
161
162 if (cairo_surface_set_user_data (surface,
163 &finalize_closure_key,
164 (void *) ansi_closure,
165 (cairo_destroy_func_t) g_free))
166 g_free ((void *) closure);
167
168 return surface;
169 }
170
171
172 #ifdef CAIRO_HAS_PNG_FUNCTIONS
173
174 static void
finalize_png(finalize_closure_t * closure)175 finalize_png (finalize_closure_t *closure)
176 {
177 cairo_status_t status;
178 status = cairo_surface_write_to_png_stream (closure->surface,
179 closure->write_func,
180 closure->closure);
181 if (status != CAIRO_STATUS_SUCCESS)
182 fail (false, "Failed to write output: %s",
183 cairo_status_to_string (status));
184 }
185
186 static cairo_surface_t *
_cairo_png_surface_create_for_stream(cairo_write_func_t write_func,void * closure,double width,double height,cairo_content_t content)187 _cairo_png_surface_create_for_stream (cairo_write_func_t write_func,
188 void *closure,
189 double width,
190 double height,
191 cairo_content_t content)
192 {
193 cairo_surface_t *surface;
194 int w = ceil (width);
195 int h = ceil (height);
196
197 switch (content) {
198 case CAIRO_CONTENT_ALPHA:
199 surface = cairo_image_surface_create (CAIRO_FORMAT_A8, w, h);
200 break;
201 default:
202 case CAIRO_CONTENT_COLOR:
203 surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
204 break;
205 case CAIRO_CONTENT_COLOR_ALPHA:
206 surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, w, h);
207 break;
208 }
209 cairo_status_t status = cairo_surface_status (surface);
210 if (status != CAIRO_STATUS_SUCCESS)
211 fail (false, "Failed to create cairo surface: %s",
212 cairo_status_to_string (status));
213
214 finalize_closure_t *png_closure = g_new0 (finalize_closure_t, 1);
215 png_closure->callback = finalize_png;
216 png_closure->surface = surface;
217 png_closure->write_func = write_func;
218 png_closure->closure = closure;
219
220 if (cairo_surface_set_user_data (surface,
221 &finalize_closure_key,
222 (void *) png_closure,
223 (cairo_destroy_func_t) g_free))
224 g_free ((void *) closure);
225
226 return surface;
227 }
228
229 #endif
230
231 static cairo_status_t
stdio_write_func(void * closure,const unsigned char * data,unsigned int size)232 stdio_write_func (void *closure,
233 const unsigned char *data,
234 unsigned int size)
235 {
236 FILE *fp = (FILE *) closure;
237
238 while (size) {
239 size_t ret = fwrite (data, 1, size, fp);
240 size -= ret;
241 data += ret;
242 if (size && ferror (fp))
243 fail (false, "Failed to write output: %s", strerror (errno));
244 }
245
246 return CAIRO_STATUS_SUCCESS;
247 }
248
249 const char helper_cairo_supported_formats[] =
250 "ansi"
251 #ifdef CAIRO_HAS_PNG_FUNCTIONS
252 "/png"
253 #endif
254 #ifdef CAIRO_HAS_SVG_SURFACE
255 "/svg"
256 #endif
257 #ifdef CAIRO_HAS_PDF_SURFACE
258 "/pdf"
259 #endif
260 #ifdef CAIRO_HAS_PS_SURFACE
261 "/ps"
262 #ifdef HAS_EPS
263 "/eps"
264 #endif
265 #endif
266 ;
267
268 cairo_t *
helper_cairo_create_context(double w,double h,view_options_t * view_opts,output_options_t * out_opts)269 helper_cairo_create_context (double w, double h,
270 view_options_t *view_opts,
271 output_options_t *out_opts)
272 {
273 cairo_surface_t *(*constructor) (cairo_write_func_t write_func,
274 void *closure,
275 double width,
276 double height) = NULL;
277 cairo_surface_t *(*constructor2) (cairo_write_func_t write_func,
278 void *closure,
279 double width,
280 double height,
281 cairo_content_t content) = NULL;
282
283 const char *extension = out_opts->output_format;
284 if (!extension) {
285 #if HAVE_ISATTY
286 if (isatty (fileno (out_opts->get_file_handle ())))
287 extension = "ansi";
288 else
289 #endif
290 {
291 #ifdef CAIRO_HAS_PNG_FUNCTIONS
292 extension = "png";
293 #else
294 extension = "ansi";
295 #endif
296 }
297 }
298 if (0)
299 ;
300 else if (0 == strcasecmp (extension, "ansi"))
301 constructor2 = _cairo_ansi_surface_create_for_stream;
302 #ifdef CAIRO_HAS_PNG_FUNCTIONS
303 else if (0 == strcasecmp (extension, "png"))
304 constructor2 = _cairo_png_surface_create_for_stream;
305 #endif
306 #ifdef CAIRO_HAS_SVG_SURFACE
307 else if (0 == strcasecmp (extension, "svg"))
308 constructor = cairo_svg_surface_create_for_stream;
309 #endif
310 #ifdef CAIRO_HAS_PDF_SURFACE
311 else if (0 == strcasecmp (extension, "pdf"))
312 constructor = cairo_pdf_surface_create_for_stream;
313 #endif
314 #ifdef CAIRO_HAS_PS_SURFACE
315 else if (0 == strcasecmp (extension, "ps"))
316 constructor = cairo_ps_surface_create_for_stream;
317 #ifdef HAS_EPS
318 else if (0 == strcasecmp (extension, "eps"))
319 constructor = _cairo_eps_surface_create_for_stream;
320 #endif
321 #endif
322
323
324 unsigned int fr, fg, fb, fa, br, bg, bb, ba;
325 br = bg = bb = 0; ba = 255;
326 sscanf (view_opts->back + (*view_opts->back=='#'), "%2x%2x%2x%2x", &br, &bg, &bb, &ba);
327 fr = fg = fb = 0; fa = 255;
328 sscanf (view_opts->fore + (*view_opts->fore=='#'), "%2x%2x%2x%2x", &fr, &fg, &fb, &fa);
329
330 cairo_content_t content;
331 if (!view_opts->annotate && ba == 255 && br == bg && bg == bb && fr == fg && fg == fb)
332 content = CAIRO_CONTENT_ALPHA;
333 else if (ba == 255)
334 content = CAIRO_CONTENT_COLOR;
335 else
336 content = CAIRO_CONTENT_COLOR_ALPHA;
337
338 cairo_surface_t *surface;
339 FILE *f = out_opts->get_file_handle ();
340 if (constructor)
341 surface = constructor (stdio_write_func, f, w, h);
342 else if (constructor2)
343 surface = constructor2 (stdio_write_func, f, w, h, content);
344 else
345 fail (false, "Unknown output format `%s'; supported formats are: %s%s",
346 extension, helper_cairo_supported_formats,
347 out_opts->explicit_output_format ? "" :
348 "\nTry setting format using --output-format");
349
350 cairo_t *cr = cairo_create (surface);
351 content = cairo_surface_get_content (surface);
352
353 switch (content) {
354 case CAIRO_CONTENT_ALPHA:
355 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
356 cairo_set_source_rgba (cr, 1., 1., 1., br / 255.);
357 cairo_paint (cr);
358 cairo_set_source_rgba (cr, 1., 1., 1.,
359 (fr / 255.) * (fa / 255.) + (br / 255) * (1 - (fa / 255.)));
360 break;
361 default:
362 case CAIRO_CONTENT_COLOR:
363 case CAIRO_CONTENT_COLOR_ALPHA:
364 cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
365 cairo_set_source_rgba (cr, br / 255., bg / 255., bb / 255., ba / 255.);
366 cairo_paint (cr);
367 cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
368 cairo_set_source_rgba (cr, fr / 255., fg / 255., fb / 255., fa / 255.);
369 break;
370 }
371
372 cairo_surface_destroy (surface);
373 return cr;
374 }
375
376 void
helper_cairo_destroy_context(cairo_t * cr)377 helper_cairo_destroy_context (cairo_t *cr)
378 {
379 finalize_closure_t *closure = (finalize_closure_t *)
380 cairo_surface_get_user_data (cairo_get_target (cr),
381 &finalize_closure_key);
382 if (closure)
383 closure->callback (closure);
384
385 cairo_status_t status = cairo_status (cr);
386 if (status != CAIRO_STATUS_SUCCESS)
387 fail (false, "Failed: %s",
388 cairo_status_to_string (status));
389 cairo_destroy (cr);
390 }
391
392
393 void
helper_cairo_line_from_buffer(helper_cairo_line_t * l,hb_buffer_t * buffer,const char * text,unsigned int text_len,double scale,hb_bool_t utf8_clusters)394 helper_cairo_line_from_buffer (helper_cairo_line_t *l,
395 hb_buffer_t *buffer,
396 const char *text,
397 unsigned int text_len,
398 double scale,
399 hb_bool_t utf8_clusters)
400 {
401 memset (l, 0, sizeof (*l));
402
403 l->num_glyphs = hb_buffer_get_length (buffer);
404 hb_glyph_info_t *hb_glyph = hb_buffer_get_glyph_infos (buffer, NULL);
405 hb_glyph_position_t *hb_position = hb_buffer_get_glyph_positions (buffer, NULL);
406 l->glyphs = cairo_glyph_allocate (l->num_glyphs + 1);
407
408 if (text) {
409 l->utf8 = g_strndup (text, text_len);
410 l->utf8_len = text_len;
411 l->num_clusters = l->num_glyphs ? 1 : 0;
412 for (unsigned int i = 1; i < l->num_glyphs; i++)
413 if (hb_glyph[i].cluster != hb_glyph[i-1].cluster)
414 l->num_clusters++;
415 l->clusters = cairo_text_cluster_allocate (l->num_clusters);
416 }
417
418 if ((l->num_glyphs && !l->glyphs) ||
419 (l->utf8_len && !l->utf8) ||
420 (l->num_clusters && !l->clusters))
421 {
422 l->finish ();
423 return;
424 }
425
426 hb_position_t x = 0, y = 0;
427 int i;
428 for (i = 0; i < (int) l->num_glyphs; i++)
429 {
430 l->glyphs[i].index = hb_glyph[i].codepoint;
431 l->glyphs[i].x = ( hb_position->x_offset + x) * scale;
432 l->glyphs[i].y = (-hb_position->y_offset + y) * scale;
433 x += hb_position->x_advance;
434 y += -hb_position->y_advance;
435
436 hb_position++;
437 }
438 l->glyphs[i].index = -1;
439 l->glyphs[i].x = x * scale;
440 l->glyphs[i].y = y * scale;
441
442 if (l->num_clusters) {
443 memset ((void *) l->clusters, 0, l->num_clusters * sizeof (l->clusters[0]));
444 hb_bool_t backward = HB_DIRECTION_IS_BACKWARD (hb_buffer_get_direction (buffer));
445 l->cluster_flags = backward ? CAIRO_TEXT_CLUSTER_FLAG_BACKWARD : (cairo_text_cluster_flags_t) 0;
446 unsigned int cluster = 0;
447 const char *start = l->utf8, *end;
448 l->clusters[cluster].num_glyphs++;
449 if (backward) {
450 for (i = l->num_glyphs - 2; i >= 0; i--) {
451 if (hb_glyph[i].cluster != hb_glyph[i+1].cluster) {
452 g_assert (hb_glyph[i].cluster > hb_glyph[i+1].cluster);
453 if (utf8_clusters)
454 end = start + hb_glyph[i].cluster - hb_glyph[i+1].cluster;
455 else
456 end = g_utf8_offset_to_pointer (start, hb_glyph[i].cluster - hb_glyph[i+1].cluster);
457 l->clusters[cluster].num_bytes = end - start;
458 start = end;
459 cluster++;
460 }
461 l->clusters[cluster].num_glyphs++;
462 }
463 l->clusters[cluster].num_bytes = l->utf8 + text_len - start;
464 } else {
465 for (i = 1; i < (int) l->num_glyphs; i++) {
466 if (hb_glyph[i].cluster != hb_glyph[i-1].cluster) {
467 g_assert (hb_glyph[i].cluster > hb_glyph[i-1].cluster);
468 if (utf8_clusters)
469 end = start + hb_glyph[i].cluster - hb_glyph[i-1].cluster;
470 else
471 end = g_utf8_offset_to_pointer (start, hb_glyph[i].cluster - hb_glyph[i-1].cluster);
472 l->clusters[cluster].num_bytes = end - start;
473 start = end;
474 cluster++;
475 }
476 l->clusters[cluster].num_glyphs++;
477 }
478 l->clusters[cluster].num_bytes = l->utf8 + text_len - start;
479 }
480 }
481 }
482