1 /*
2 * Inkscape::Text::Layout - text layout engine output functions
3 *
4 * Authors:
5 * Richard Hughes <cyreve@users.sf.net>
6 *
7 * Copyright (C) 2005 Richard Hughes
8 *
9 * Released under GNU GPL, read the file 'COPYING' for more information
10 */
11 #include <glib/gmem.h>
12 #include "Layout-TNG.h"
13 #include "display/nr-arena-glyphs.h"
14 #include "style.h"
15 #include "print.h"
16 #include "extension/print.h"
17 #include "livarot/Path.h"
18 #include "libnr/nr-scale-matrix-ops.h"
19 #include "font-instance.h"
20 #include "svg/svg-length.h"
22 namespace Inkscape {
23 namespace Text {
25 void Layout::_clearOutputObjects()
26 {
27 _paragraphs.clear();
28 _lines.clear();
29 _chunks.clear();
30 for (std::vector<Span>::iterator it_span = _spans.begin() ; it_span != _spans.end() ; it_span++)
31 if (it_span->font) it_span->font->Unref();
32 _spans.clear();
33 _characters.clear();
34 _glyphs.clear();
35 _path_fitted = NULL;
36 }
38 void Layout::LineHeight::max(LineHeight const &other)
39 {
40 if (other.ascent > ascent) ascent = other.ascent;
41 if (other.descent > descent) descent = other.descent;
42 if (other.leading > leading) leading = other.leading;
43 }
45 void Layout::_getGlyphTransformMatrix(int glyph_index, NRMatrix *matrix) const
46 {
47 Span const &span = _glyphs[glyph_index].span(this);
48 double sin_rotation = sin(_glyphs[glyph_index].rotation);
49 double cos_rotation = cos(_glyphs[glyph_index].rotation);
50 (*matrix)[0] = span.font_size * cos_rotation;
51 (*matrix)[1] = span.font_size * sin_rotation;
52 (*matrix)[2] = span.font_size * sin_rotation;
53 (*matrix)[3] = -span.font_size * cos_rotation;
54 if (span.block_progression == LEFT_TO_RIGHT || span.block_progression == RIGHT_TO_LEFT) {
55 (*matrix)[4] = _lines[_chunks[span.in_chunk].in_line].baseline_y + _glyphs[glyph_index].y;
56 (*matrix)[5] = _chunks[span.in_chunk].left_x + _glyphs[glyph_index].x;
57 } else {
58 (*matrix)[4] = _chunks[span.in_chunk].left_x + _glyphs[glyph_index].x;
59 (*matrix)[5] = _lines[_chunks[span.in_chunk].in_line].baseline_y + _glyphs[glyph_index].y;
60 }
61 }
63 void Layout::show(NRArenaGroup *in_arena, NRRect const *paintbox) const
64 {
65 int glyph_index = 0;
66 for (unsigned span_index = 0 ; span_index < _spans.size() ; span_index++) {
67 if (_input_stream[_spans[span_index].in_input_stream_item]->Type() != TEXT_SOURCE) continue;
68 InputStreamTextSource const *text_source = static_cast<InputStreamTextSource const *>(_input_stream[_spans[span_index].in_input_stream_item]);
69 NRArenaGlyphsGroup *nr_group = NRArenaGlyphsGroup::create(in_arena->arena);
70 nr_arena_item_add_child(in_arena, nr_group, NULL);
71 nr_arena_item_unref(nr_group);
73 nr_arena_glyphs_group_set_style(nr_group, text_source->style);
74 while (glyph_index < (int)_glyphs.size() && _characters[_glyphs[glyph_index].in_character].in_span == span_index) {
75 if (_characters[_glyphs[glyph_index].in_character].in_glyph != -1) {
76 NRMatrix glyph_matrix;
77 _getGlyphTransformMatrix(glyph_index, &glyph_matrix);
78 nr_arena_glyphs_group_add_component(nr_group, _spans[span_index].font, _glyphs[glyph_index].glyph, &glyph_matrix);
79 }
80 glyph_index++;
81 }
82 nr_arena_glyphs_group_set_paintbox(NR_ARENA_GLYPHS_GROUP(nr_group), paintbox);
83 }
84 nr_arena_item_request_update(NR_ARENA_ITEM(in_arena), NR_ARENA_ITEM_STATE_ALL, FALSE);
85 }
87 void Layout::getBoundingBox(NRRect *bounding_box, NR::Matrix const &transform, int start, int length) const
88 {
89 for (unsigned glyph_index = 0 ; glyph_index < _glyphs.size() ; glyph_index++) {
90 if (_characters[_glyphs[glyph_index].in_character].in_glyph == -1) continue;
91 if (start != -1 && (int) _glyphs[glyph_index].in_character < start) continue;
92 if (length != -1) {
93 if (start == -1)
94 start = 0;
95 if ((int) _glyphs[glyph_index].in_character > start + length) continue;
96 }
97 // this could be faster
98 NRMatrix glyph_matrix;
99 _getGlyphTransformMatrix(glyph_index, &glyph_matrix);
100 NR::Matrix total_transform = glyph_matrix;
101 total_transform *= transform;
102 NR::Rect glyph_rect = _glyphs[glyph_index].span(this).font->BBox(_glyphs[glyph_index].glyph);
103 NR::Point bmi = glyph_rect.min(), bma = glyph_rect.max();
104 NR::Point tlp(bmi[0],bmi[1]), trp(bma[0],bmi[1]), blp(bmi[0],bma[1]), brp(bma[0],bma[1]);
105 tlp *= total_transform;
106 trp *= total_transform;
107 blp *= total_transform;
108 brp *= total_transform;
109 glyph_rect = NR::Rect(tlp,trp);
110 glyph_rect.expandTo(blp);
111 glyph_rect.expandTo(brp);
112 if ( (glyph_rect.min())[0] < bounding_box->x0 ) bounding_box->x0=(glyph_rect.min())[0];
113 if ( (glyph_rect.max())[0] > bounding_box->x1 ) bounding_box->x1=(glyph_rect.max())[0];
114 if ( (glyph_rect.min())[1] < bounding_box->y0 ) bounding_box->y0=(glyph_rect.min())[1];
115 if ( (glyph_rect.max())[1] > bounding_box->y1 ) bounding_box->y1=(glyph_rect.max())[1];
116 }
117 }
119 void Layout::print(SPPrintContext *ctx,
120 NRRect const *pbox, NRRect const *dbox, NRRect const *bbox,
121 NRMatrix const &ctm) const
122 {
123 if (_input_stream.empty()) return;
125 Direction block_progression = _blockProgression();
126 bool text_to_path = ctx->module->textToPath();
127 for (unsigned glyph_index = 0 ; glyph_index < _glyphs.size() ; ) {
128 if (_characters[_glyphs[glyph_index].in_character].in_glyph == -1) {
129 // invisible glyphs
130 unsigned same_character = _glyphs[glyph_index].in_character;
131 while (_glyphs[glyph_index].in_character == same_character)
132 glyph_index++;
133 continue;
134 }
135 NRMatrix glyph_matrix;
136 Span const &span = _spans[_characters[_glyphs[glyph_index].in_character].in_span];
137 InputStreamTextSource const *text_source = static_cast<InputStreamTextSource const *>(_input_stream[span.in_input_stream_item]);
138 if (text_to_path || _path_fitted) {
139 NRBPath bpath;
140 bpath.path = (NArtBpath*)span.font->ArtBPath(_glyphs[glyph_index].glyph);
141 if (bpath.path) {
142 NRBPath abp;
143 _getGlyphTransformMatrix(glyph_index, &glyph_matrix);
144 abp.path = nr_artpath_affine(bpath.path, glyph_matrix);
145 if (text_source->style->fill.type != SP_PAINT_TYPE_NONE)
146 sp_print_fill(ctx, &abp, &ctm, text_source->style, pbox, dbox, bbox);
147 if (text_source->style->stroke.type != SP_PAINT_TYPE_NONE)
148 sp_print_stroke(ctx, &abp, &ctm, text_source->style, pbox, dbox, bbox);
149 g_free(abp.path);
150 }
151 glyph_index++;
152 } else {
153 NR::Point g_pos(0,0); // all strings are output at (0,0) because we do the translation using the matrix
154 glyph_matrix = NR::Matrix(NR::scale(1.0, -1.0) * NR::Matrix(NR::rotate(_glyphs[glyph_index].rotation)));
155 if (block_progression == LEFT_TO_RIGHT || block_progression == RIGHT_TO_LEFT) {
156 glyph_matrix.c[4] = span.line(this).baseline_y + span.baseline_shift;
157 // since we're outputting character codes, not glyphs, we want the character x
158 glyph_matrix.c[5] = span.chunk(this).left_x + span.x_start + _characters[_glyphs[glyph_index].in_character].x;
159 } else {
160 glyph_matrix.c[4] = span.chunk(this).left_x + span.x_start + _characters[_glyphs[glyph_index].in_character].x;
161 glyph_matrix.c[5] = span.line(this).baseline_y + span.baseline_shift;
162 }
163 Glib::ustring::const_iterator span_iter = span.input_stream_first_character;
164 unsigned char_index = _glyphs[glyph_index].in_character;
165 unsigned original_span = _characters[char_index].in_span;
166 while (char_index && _characters[char_index - 1].in_span == original_span) {
167 char_index--;
168 span_iter++;
169 }
171 // try to output as many characters as possible in one go by detecting kerning and stopping when we encounter it
172 Glib::ustring span_string;
173 double char_x = _characters[_glyphs[glyph_index].in_character].x;
174 unsigned this_span_index = _characters[_glyphs[glyph_index].in_character].in_span;
175 do {
176 span_string += *span_iter;
177 span_iter++;
179 unsigned same_character = _glyphs[glyph_index].in_character;
180 while (glyph_index < _glyphs.size() && _glyphs[glyph_index].in_character == same_character) {
181 char_x += _glyphs[glyph_index].width;
182 glyph_index++;
183 }
184 } while (glyph_index < _glyphs.size()
185 && _path_fitted == NULL
186 && _characters[_glyphs[glyph_index].in_character].in_span == this_span_index
187 && fabs(char_x - _characters[_glyphs[glyph_index].in_character].x) < 1e-5);
188 sp_print_bind(ctx, glyph_matrix, 1.0);
189 sp_print_text(ctx, span_string.c_str(), g_pos, text_source->style);
190 sp_print_release(ctx);
191 }
192 }
193 }
195 // these functions are for dumpAsText() only. No need to translate
196 static char const *direction_to_text(Layout::Direction d)
197 {
198 switch (d) {
199 case Layout::LEFT_TO_RIGHT: return "ltr";
200 case Layout::RIGHT_TO_LEFT: return "rtl";
201 case Layout::TOP_TO_BOTTOM: return "ttb";
202 case Layout::BOTTOM_TO_TOP: return "btt";
203 }
204 return "???";
205 }
207 static char const *style_to_text(PangoStyle s)
208 {
209 switch (s) {
210 case PANGO_STYLE_NORMAL: return "upright";
211 case PANGO_STYLE_ITALIC: return "italic";
212 case PANGO_STYLE_OBLIQUE: return "oblique";
213 }
214 return "???";
215 }
217 static char const *weight_to_text(PangoWeight w)
218 {
219 switch (w) {
220 case PANGO_WEIGHT_ULTRALIGHT: return "ultralight";
221 case PANGO_WEIGHT_LIGHT : return "light";
222 case PANGO_WEIGHT_SEMIBOLD : return "semibold";
223 case PANGO_WEIGHT_NORMAL : return "normalweight";
224 case PANGO_WEIGHT_BOLD : return "bold";
225 case PANGO_WEIGHT_ULTRABOLD : return "ultrabold";
226 case PANGO_WEIGHT_HEAVY : return "heavy";
227 }
228 return "???";
229 }
231 Glib::ustring Layout::dumpAsText() const
232 {
233 Glib::ustring result;
235 for (unsigned span_index = 0 ; span_index < _spans.size() ; span_index++) {
236 char line[256];
237 snprintf(line, sizeof(line), "==== span %d\n", span_index);
238 result += line;
239 snprintf(line, sizeof(line), " in para %d (direction=%s)\n", _lines[_chunks[_spans[span_index].in_chunk].in_line].in_paragraph,
240 direction_to_text(_paragraphs[_lines[_chunks[_spans[span_index].in_chunk].in_line].in_paragraph].base_direction));
241 result += line;
242 snprintf(line, sizeof(line), " in source %d (type=%d, cookie=%p)\n", _spans[span_index].in_input_stream_item,
243 _input_stream[_spans[span_index].in_input_stream_item]->Type(),
244 _input_stream[_spans[span_index].in_input_stream_item]->source_cookie);
245 result += line;
246 snprintf(line, sizeof(line), " in line %d (baseline=%f, shape=%d)\n", _chunks[_spans[span_index].in_chunk].in_line,
247 _lines[_chunks[_spans[span_index].in_chunk].in_line].baseline_y,
248 _lines[_chunks[_spans[span_index].in_chunk].in_line].in_shape);
249 result += line;
250 snprintf(line, sizeof(line), " in chunk %d (x=%f, baselineshift=%f)\n", _spans[span_index].in_chunk, _chunks[_spans[span_index].in_chunk].left_x, _spans[span_index].baseline_shift);
251 result += line;
252 if (_spans[span_index].font) {
253 snprintf(line, sizeof(line), " font '%s' %f %s %s\n", pango_font_description_get_family(_spans[span_index].font->descr), _spans[span_index].font_size, style_to_text(pango_font_description_get_style(_spans[span_index].font->descr)), weight_to_text(pango_font_description_get_weight(_spans[span_index].font->descr)));
254 result += line;
255 }
256 snprintf(line, sizeof(line), " x_start = %f, x_end = %f\n", _spans[span_index].x_start, _spans[span_index].x_end);
257 result += line;
258 snprintf(line, sizeof(line), " line height: ascent %f, descent %f leading %f\n", _spans[span_index].line_height.ascent, _spans[span_index].line_height.descent, _spans[span_index].line_height.leading);
259 result += line;
260 snprintf(line, sizeof(line), " direction %s, block-progression %s\n", direction_to_text(_spans[span_index].direction), direction_to_text(_spans[span_index].block_progression));
261 result += line;
262 result += " ** characters:\n";
263 Glib::ustring::const_iterator iter_char = _spans[span_index].input_stream_first_character;
264 // very inefficent code. what the hell, it's only debug stuff.
265 for (unsigned char_index = 0 ; char_index < _characters.size() ; char_index++) {
266 if (_characters[char_index].in_span != span_index) continue;
267 if (_input_stream[_spans[span_index].in_input_stream_item]->Type() != TEXT_SOURCE) {
268 snprintf(line, sizeof(line), " %d: control x=%f flags=%03x glyph=%d\n", char_index, _characters[char_index].x, *(unsigned*)&_characters[char_index].char_attributes, _characters[char_index].in_glyph);
269 } else {
270 snprintf(line, sizeof(line), " %d: '%c' x=%f flags=%03x glyph=%d\n", char_index, *iter_char, _characters[char_index].x, *(unsigned*)&_characters[char_index].char_attributes, _characters[char_index].in_glyph);
271 iter_char++;
272 }
273 result += line;
274 }
275 result += " ** glyphs:\n";
276 for (unsigned glyph_index = 0 ; glyph_index < _glyphs.size() ; glyph_index++) {
277 if (_characters[_glyphs[glyph_index].in_character].in_span != span_index) continue;
278 snprintf(line, sizeof(line), " %d: %d (%f,%f) rot=%f cx=%f char=%d\n", glyph_index, _glyphs[glyph_index].glyph, _glyphs[glyph_index].x, _glyphs[glyph_index].y, _glyphs[glyph_index].rotation, _glyphs[glyph_index].width, _glyphs[glyph_index].in_character);
279 result += line;
280 }
281 result += "\n";
282 }
283 result += "EOT\n";
284 return result;
285 }
287 void Layout::fitToPathAlign(SVGLength const &startOffset, Path const &path)
288 {
289 double offset = 0.0;
291 if (startOffset._set) {
292 if (startOffset.unit == SVGLength::PERCENT)
293 offset = startOffset.computed * const_cast<Path&>(path).Length();
294 else
295 offset = startOffset.computed;
296 }
298 switch (_paragraphs.front().alignment) {
299 case CENTER:
300 offset -= _getChunkWidth(0) * 0.5;
301 break;
302 case RIGHT:
303 offset -= _getChunkWidth(0);
304 break;
305 default:
306 break;
307 }
309 if (_characters.empty()) {
310 int unused = 0;
311 Path::cut_position *point_otp = const_cast<Path&>(path).CurvilignToPosition(1, &offset, unused);
312 if (offset >= 0.0 && point_otp != NULL && point_otp[0].piece >= 0) {
313 NR::Point point;
314 NR::Point tangent;
315 const_cast<Path&>(path).PointAndTangentAt(point_otp[0].piece, point_otp[0].t, point, tangent);
316 _empty_cursor_shape.position = point;
317 _empty_cursor_shape.rotation = atan2(tangent[NR::Y], tangent[NR::X]);
318 }
319 }
321 for (unsigned char_index = 0 ; char_index < _characters.size() ; ) {
322 int next_cluster_glyph_index;
323 unsigned next_cluster_char_index;
324 double character_advance;
325 Span const &span = _characters[char_index].span(this);
327 for (next_cluster_char_index = char_index + 1 ;
328 next_cluster_char_index < _characters.size() && !_characters[next_cluster_char_index].char_attributes.is_cursor_position;
329 next_cluster_char_index++);
331 if (next_cluster_char_index == _characters.size()) {
332 next_cluster_glyph_index = _glyphs.size();
333 character_advance = 0.0; // arbitrary because we're not going to advance
334 } else {
335 next_cluster_glyph_index = _characters[next_cluster_char_index].in_glyph;
336 character_advance = (_glyphs[next_cluster_glyph_index].x + _glyphs[next_cluster_glyph_index].chunk(this).left_x)
337 - (_glyphs[_characters[char_index].in_glyph].x + span.chunk(this).left_x);
338 }
340 double start_offset = offset + span.x_start + _characters[char_index].x;
341 double cluster_width = 0.0;
342 for (int glyph_index = _characters[char_index].in_glyph ; glyph_index < next_cluster_glyph_index ; glyph_index++)
343 cluster_width += _glyphs[glyph_index].width;
344 if (span.direction == RIGHT_TO_LEFT)
345 start_offset -= cluster_width;
346 double end_offset = start_offset + cluster_width;
348 int unused = 0;
349 double midpoint_offset = (start_offset + end_offset) * 0.5;
350 // as far as I know these functions are const, they're just not marked as such
351 Path::cut_position *midpoint_otp = const_cast<Path&>(path).CurvilignToPosition(1, &midpoint_offset, unused);
352 if (midpoint_offset >= 0.0 && midpoint_otp != NULL && midpoint_otp[0].piece >= 0) {
353 NR::Point midpoint;
354 NR::Point tangent;
356 const_cast<Path&>(path).PointAndTangentAt(midpoint_otp[0].piece, midpoint_otp[0].t, midpoint, tangent);
358 if (start_offset >= 0.0 && end_offset >= 0.0) {
359 Path::cut_position *start_otp = const_cast<Path&>(path).CurvilignToPosition(1, &start_offset, unused);
360 if (start_otp != NULL && start_otp[0].piece >= 0) {
361 Path::cut_position *end_otp = const_cast<Path&>(path).CurvilignToPosition(1, &end_offset, unused);
362 if (end_otp != NULL && end_otp[0].piece >= 0) {
363 bool on_same_subpath = true;
364 for (size_t i = 0 ; i < path.pts.size() ; i++) {
365 if (path.pts[i].piece <= start_otp[0].piece) continue;
366 if (path.pts[i].piece >= end_otp[0].piece) break;
367 if (path.pts[i].isMoveTo == polyline_moveto) {
368 on_same_subpath = false;
369 break;
370 }
371 }
372 if (on_same_subpath) {
373 // both points were on the same subpath (without this test the angle is very weird)
374 NR::Point startpoint, endpoint;
375 const_cast<Path&>(path).PointAt(start_otp[0].piece, start_otp[0].t, startpoint);
376 const_cast<Path&>(path).PointAt(end_otp[0].piece, end_otp[0].t, endpoint);
377 if (endpoint != startpoint) {
378 tangent = endpoint - startpoint;
379 tangent.normalize();
380 } else {
381 tangent = NR::Point (0,0);
382 }
383 }
384 g_free(end_otp);
385 }
386 g_free(start_otp);
387 }
388 }
390 double rotation = atan2(tangent[1], tangent[0]);
391 for (int glyph_index = _characters[char_index].in_glyph ; glyph_index < next_cluster_glyph_index ; glyph_index++) {
392 double tangent_shift = -cluster_width * 0.5 + _glyphs[glyph_index].x - (_characters[char_index].x + span.x_start);
393 double normal_shift = _glyphs[glyph_index].y;
394 if (span.direction == RIGHT_TO_LEFT)
395 tangent_shift += cluster_width;
396 _glyphs[glyph_index].x = midpoint[0] - span.chunk(this).left_x + tangent[0] * tangent_shift - tangent[1] * normal_shift;
397 _glyphs[glyph_index].y = midpoint[1] - _lines.front().baseline_y + tangent[1] * tangent_shift + tangent[0] * normal_shift;
398 _glyphs[glyph_index].rotation += rotation;
399 }
400 } else { // outside the bounds of the path: hide the glyphs
401 _characters[char_index].in_glyph = -1;
402 }
403 g_free(midpoint_otp);
405 char_index = next_cluster_char_index;
406 }
408 for (unsigned span_index = 0 ; span_index < _spans.size() ; span_index++) {
409 _spans[span_index].x_start += offset;
410 _spans[span_index].x_end += offset;
411 }
413 _path_fitted = &path;
414 }
416 SPCurve *Layout::convertToCurves(iterator const &from_glyph, iterator const &to_glyph) const
417 {
418 GSList *cc = NULL;
420 for (int glyph_index = from_glyph._glyph_index ; glyph_index < to_glyph._glyph_index ; glyph_index++) {
421 NRMatrix glyph_matrix;
422 Span const &span = _glyphs[glyph_index].span(this);
423 _getGlyphTransformMatrix(glyph_index, &glyph_matrix);
425 NRBPath bpath;
426 bpath.path = (NArtBpath*)span.font->ArtBPath(_glyphs[glyph_index].glyph);
427 if (bpath.path) {
428 NArtBpath *abp = nr_artpath_affine(bpath.path, glyph_matrix);
429 SPCurve *c = sp_curve_new_from_bpath(abp);
430 if (c) cc = g_slist_prepend(cc, c);
431 }
432 }
433 cc = g_slist_reverse(cc);
435 SPCurve *curve;
436 if ( cc ) {
437 curve = sp_curve_concat(cc);
438 } else {
439 curve = sp_curve_new();
440 }
442 while (cc) {
443 /* fixme: This is dangerous, as we are mixing art_alloc and g_new */
444 sp_curve_unref((SPCurve *) cc->data);
445 cc = g_slist_remove(cc, cc->data);
446 }
448 return curve;
449 }
451 void Layout::transform(NR::Matrix const &transform)
452 {
453 // this is all massively oversimplified
454 // I can't actually think of anybody who'll want to use it at the moment, so it'll stay simple
455 for (unsigned glyph_index = 0 ; glyph_index < _glyphs.size() ; glyph_index++) {
456 NR::Point point(_glyphs[glyph_index].x, _glyphs[glyph_index].y);
457 point *= transform;
458 _glyphs[glyph_index].x = point[0];
459 _glyphs[glyph_index].y = point[1];
460 }
461 }
463 }//namespace Text
464 }//namespace Inkscape
467 /*
468 Local Variables:
469 mode:c++
470 c-file-style:"stroustrup"
471 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
472 indent-tabs-mode:nil
473 fill-column:99
474 End:
475 */
476 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :