WebSVN – Kolibri OS – Diff – /programs/develop/libraries/cairo/src/cairo-pdf-operators.c

+ *
  * Note: This stream does not guarantee that the output will never
  * exceed max_column. In particular, if a single word is larger than
  * max_column it will not be broken up.
  */
+typedef enum _cairo_word_wrap_state {
+    WRAP_STATE_DELIMITER,
+    WRAP_STATE_WORD,
+    WRAP_STATE_STRING,
+    WRAP_STATE_HEXSTRING
+} cairo_word_wrap_state_t;
 typedef struct _word_wrap_stream {
     cairo_output_stream_t base;
     cairo_output_stream_t *output;
     int max_column;
     int column;
-    cairo_bool_t last_write_was_space;
+    cairo_word_wrap_state_t state;
-    cairo_bool_t in_hexstring;
+    cairo_bool_t in_escape;
-    cairo_bool_t empty_hexstring;
+    int		 escape_digits;
 } word_wrap_stream_t;
 /* Emit word bytes up to the next delimiter character */
+static int
-static int
+_word_wrap_stream_count_word_up_to (word_wrap_stream_t *stream,
-_count_word_up_to (const unsigned char *s, int length)
+				   const unsigned char *data, int length)
+{
-{
+    const unsigned char *s = data;
-    int word = 0;
+    int count = 0;
     while (length--) {
-	if (! (_cairo_isspace (*s) || *s == '<')) {
+	if (_cairo_isspace (*s) || *s == '<' || *s == '(') {
-	    s++;
-	    word++;
-	} else {
+	    stream->state = WRAP_STATE_DELIMITER;
+	    break;
+	}
+	count++;
-	    return word;
+	stream->column++;
+	s++;
+    }
-	}
+    if (count)
 	_cairo_output_stream_write (stream->output, data, count);
-    return word;
+    return count;
+}
+/* Emit hexstring bytes up to either the end of the ASCII hexstring or the number
-/* Count up to either the end of the ASCII hexstring or the number
+ * of columns remaining.
+ */
- * of columns remaining.
+static int
+_word_wrap_stream_count_hexstring_up_to (word_wrap_stream_t *stream,
- */
+					 const unsigned char *data, int length)
+{
+    const unsigned char *s = data;
-static int
+    int count = 0;
+    cairo_bool_t newline = FALSE;
-_count_hexstring_up_to (const unsigned char *s, int length, int columns)
-{
+    while (length--) {
-    int word = 0;
+	count++;
-    while (length--) {
+	stream->column++;
-	if (*s++ != '>')
+	if (*s == '>') {
-	    word++;
+	    stream->state = WRAP_STATE_DELIMITER;
+	    break;
+	}
+	if (stream->column > stream->max_column) {
+	    newline = TRUE;
+	    break;
+	}
+	s++;
+    }
+    if (count)
+	_cairo_output_stream_write (stream->output, data, count);
+    if (newline) {
+	_cairo_output_stream_printf (stream->output, "\n");
+	stream->column = 0;
+    }
+    return count;
+}
+/* Count up to either the end of the string or the number of columns
+ * remaining.
+ */
+static int
+_word_wrap_stream_count_string_up_to (word_wrap_stream_t *stream,
+				      const unsigned char *data, int length)
+{
+    const unsigned char *s = data;
+    int count = 0;
+    cairo_bool_t newline = FALSE;
+    while (length--) {
+	count++;
+	stream->column++;
+	if (!stream->in_escape) {
+	    if (*s == ')') {
+		stream->state = WRAP_STATE_DELIMITER;
+		break;
+	    }
+	    if (*s == '\\') {
+		stream->in_escape = TRUE;
+		stream->escape_digits = 0;
+	    } else if (stream->column > stream->max_column) {
+		newline = TRUE;
+		break;
+	    }
+	} else {
+	    if (!_cairo_isdigit(*s) || ++stream->escape_digits == 3)
+		stream->in_escape = FALSE;
+	}
+	s++;
+    }
-	else
+    if (count)
-	    return word;
+	_cairo_output_stream_write (stream->output, data, count);
-	columns--;
+    if (newline) {
-	if (columns < 0 && word > 1)
+	_cairo_output_stream_printf (stream->output, "\\\n");
-	    return word;
+	stream->column = 0;
+    }
-    return word;
-}
+    return count;
+}
-static cairo_status_t
-_word_wrap_stream_write (cairo_output_stream_t  *base,
+static cairo_status_t
-			 const unsigned char	*data,
-			 unsigned int		 length)
+_word_wrap_stream_write (cairo_output_stream_t  *base,
-{
+			 const unsigned char	*data,
-    word_wrap_stream_t *stream = (word_wrap_stream_t *) base;
+			 unsigned int		 length)
-    cairo_bool_t newline;
+{
-    int word;
+    word_wrap_stream_t *stream = (word_wrap_stream_t *) base;
+    int count;
-    while (length) {
-	if (*data == '<') {
-	    stream->in_hexstring = TRUE;
+    while (length) {
+	switch (stream->state) {
-	    stream->empty_hexstring = TRUE;
+	case WRAP_STATE_WORD:
-	    stream->last_write_was_space = FALSE;
-	    data++;
+	    count = _word_wrap_stream_count_word_up_to (stream, data, length);
-	    length--;
-	    _cairo_output_stream_printf (stream->output, "<");
-	    stream->column++;
+	    break;
-	} else if (*data == '>') {
+	case WRAP_STATE_HEXSTRING:
-	    stream->in_hexstring = FALSE;
+	    count = _word_wrap_stream_count_hexstring_up_to (stream, data, length);
+	    break;
+	case WRAP_STATE_STRING:
+	    count = _word_wrap_stream_count_string_up_to (stream, data, length);
+	    break;
+	case WRAP_STATE_DELIMITER:
+	    count = 1;
-	    stream->last_write_was_space = FALSE;
+	    stream->column++;
+	    if (*data == '\n' || stream->column >= stream->max_column) {
-	    data++;
+		_cairo_output_stream_printf (stream->output, "\n");
-	    length--;
+		stream->column = 0;
-	    _cairo_output_stream_printf (stream->output, ">");
-	    stream->column++;
-	} else if (_cairo_isspace (*data)) {
-	    newline =  (*data == '\n' || *data == '\r');
-	    if (! newline && stream->column >= stream->max_column) {
-		_cairo_output_stream_printf (stream->output, "\n");
-		stream->column = 0;
-	    }
-	    _cairo_output_stream_write (stream->output, data, 1);
-	    data++;
-	    length--;
-	    if (newline) {
-		stream->column = 0;
-	    }
-	    else
-		stream->column++;
-	    stream->last_write_was_space = TRUE;
-	} else {
-	    if (stream->in_hexstring) {
-		word = _count_hexstring_up_to (data, length,
-					       MAX (stream->max_column - stream->column, 0));
-	    } else {
-		word = _count_word_up_to (data, length);
+	    } else if (*data == '<') {
-	    }
+		stream->state = WRAP_STATE_HEXSTRING;
-	    /* Don't wrap if this word is a continuation of a non hex
-	     * string word from a previous call to write. */
+	    } else if (*data == '(') {
-	    if (stream->column + word >= stream->max_column) {
+		stream->state = WRAP_STATE_STRING;
-		if (stream->last_write_was_space ||
+	    } else if (!_cairo_isspace (*data)) {
-		    (stream->in_hexstring && !stream->empty_hexstring))
-		{
-		    _cairo_output_stream_printf (stream->output, "\n");
-		    stream->column = 0;
+		stream->state = WRAP_STATE_WORD;
+	    }
+	    if (*data != '\n')
 		_cairo_output_stream_write (stream->output, data, 1);
 	    break;
 	    _cairo_output_stream_write (stream->output, data, word);
 			       NULL,
 			       _word_wrap_stream_close);
     stream->output = output;
     stream->max_column = max_column;
     stream->column = 0;
-    stream->last_write_was_space = FALSE;
+    stream->state = WRAP_STATE_DELIMITER;
-    stream->in_hexstring = FALSE;
+    stream->in_escape = FALSE;
-    stream->empty_hexstring = TRUE;
+    stream->escape_digits = 0;
     return &stream->base;
+}
  * stroked, simply pass %CAIRO_LINE_CAP_ROUND which will guarantee that
  * the stroke workaround will not modify the path being emitted.
  */
 static cairo_status_t
 _cairo_pdf_operators_emit_path (cairo_pdf_operators_t	*pdf_operators,
-				cairo_path_fixed_t      *path,
+				const cairo_path_fixed_t*path,
 				cairo_matrix_t          *path_transform,
 				cairo_line_cap_t         line_cap)
+{
     cairo_output_stream_t *word_wrap;
     cairo_status_t status, status2;
     info.line_cap = line_cap;
     if (_cairo_path_fixed_is_rectangle (path, &box)) {
 	status = _cairo_pdf_path_rectangle (&info, &box);
     } else {
 	status = _cairo_path_fixed_interpret (path,
-					      CAIRO_DIRECTION_FORWARD,
 					      _cairo_pdf_path_move_to,
 					      _cairo_pdf_path_line_to,
 					      _cairo_pdf_path_curve_to,
 					      _cairo_pdf_path_close_path,
 					      &info);
     return status;
+}
 cairo_int_status_t
 _cairo_pdf_operators_clip (cairo_pdf_operators_t	*pdf_operators,
-			   cairo_path_fixed_t		*path,
+			   const cairo_path_fixed_t	*path,
 			   cairo_fill_rule_t		 fill_rule)
+{
     const char *pdf_operator;
     cairo_matrix_scale (m, s, s);
+}
 static cairo_int_status_t
 _cairo_pdf_operators_emit_stroke (cairo_pdf_operators_t		*pdf_operators,
-				  cairo_path_fixed_t		*path,
+				  const cairo_path_fixed_t	*path,
 				  const cairo_stroke_style_t	*style,
 				  const cairo_matrix_t		*ctm,
 				  const cairo_matrix_t		*ctm_inverse,
 				  const char			*pdf_operator)
 {
-    cairo_status_t status;
+    cairo_int_status_t status;
     cairo_matrix_t m, path_transform;
     cairo_bool_t has_ctm = TRUE;
     double scale = 1.0;
     return _cairo_output_stream_get_status (pdf_operators->stream);
+}
 cairo_int_status_t
 _cairo_pdf_operators_stroke (cairo_pdf_operators_t		*pdf_operators,
-			     cairo_path_fixed_t			*path,
+			     const cairo_path_fixed_t		*path,
 			     const cairo_stroke_style_t		*style,
 			     const cairo_matrix_t		*ctm,
 			     const cairo_matrix_t		*ctm_inverse)
+{
 					     "S");
+}
 cairo_int_status_t
 _cairo_pdf_operators_fill (cairo_pdf_operators_t	*pdf_operators,
-			   cairo_path_fixed_t		*path,
+			   const cairo_path_fixed_t	*path,
 			   cairo_fill_rule_t		fill_rule)
+{
     const char *pdf_operator;
     return _cairo_output_stream_get_status (pdf_operators->stream);
+}
 cairo_int_status_t
 _cairo_pdf_operators_fill_stroke (cairo_pdf_operators_t		*pdf_operators,
-				  cairo_path_fixed_t		*path,
+				  const cairo_path_fixed_t	*path,
 				  cairo_fill_rule_t		 fill_rule,
 				  const cairo_stroke_style_t	*style,
 				  const cairo_matrix_t		*ctm,
 				  const cairo_matrix_t		*ctm_inverse)
 					     ctm,
 					     ctm_inverse,
 					     operator);
+}
+static void
+_cairo_pdf_operators_emit_glyph_index (cairo_pdf_operators_t *pdf_operators,
+				       cairo_output_stream_t *stream,
+				       unsigned int 	      glyph)
+{
+    if (pdf_operators->is_latin) {
+	if (glyph == '(' || glyph == ')' || glyph == '\\')
+	    _cairo_output_stream_printf (stream, "\\%c", glyph);
+	else if (glyph >= 0x20 && glyph <= 0x7e)
+	    _cairo_output_stream_printf (stream, "%c", glyph);
+	else
+	    _cairo_output_stream_printf (stream, "\\%03o", glyph);
+    } else {
+	_cairo_output_stream_printf (stream,
+				     "%0*x",
+				     pdf_operators->hex_width,
+				     glyph);
+    }
+}
 #define GLYPH_POSITION_TOLERANCE 0.001
 /* Emit the string of glyphs using the 'Tj' operator. This requires
  * that the glyphs are positioned at their natural glyph advances. */
 static cairo_status_t
 _cairo_pdf_operators_emit_glyph_string (cairo_pdf_operators_t   *pdf_operators,
 					cairo_output_stream_t  	*stream)
 {
     int i;
-    _cairo_output_stream_printf (stream, "<");
+    _cairo_output_stream_printf (stream, "%s", pdf_operators->is_latin ? "(" : "<");
-    for (i = 0; i < pdf_operators->num_glyphs; i++) {
-	_cairo_output_stream_printf (stream,
+    for (i = 0; i < pdf_operators->num_glyphs; i++) {
-				     "%0*x",
+	_cairo_pdf_operators_emit_glyph_index (pdf_operators,
-				     pdf_operators->hex_width,
+					       stream,
-				     pdf_operators->glyphs[i].glyph_index);
+					       pdf_operators->glyphs[i].glyph_index);
 	pdf_operators->cur_x += pdf_operators->glyphs[i].x_advance;
+    }
-    _cairo_output_stream_printf (stream, ">Tj\n");
+    _cairo_output_stream_printf (stream, "%sTj\n", pdf_operators->is_latin ? ")" : ">");
     cairo_pdf_operators_t   *pdf_operators,
     cairo_output_stream_t   *stream)
+{
     int i;
-    _cairo_output_stream_printf (stream, "[<");
+    _cairo_output_stream_printf (stream, "[%s", pdf_operators->is_latin ? "(" : "<");
     for (i = 0; i < pdf_operators->num_glyphs; i++) {
 	if (pdf_operators->glyphs[i].x_position != pdf_operators->cur_x)
+	{
 	    double delta = pdf_operators->glyphs[i].x_position - pdf_operators->cur_x;
 	     * that we keep track of the accumulated rounding error in
 	     * the PDF interpreter and compensate for it when
 	     * calculating subsequent deltas.
 	     */
 	    rounded_delta = _cairo_lround (delta);
+	    if (abs(rounded_delta) < 3)
+		rounded_delta = 0;
 	    if (rounded_delta != 0) {
+		if (pdf_operators->is_latin) {
+		    _cairo_output_stream_printf (stream,
+						 ")%d(",
+						 rounded_delta);
+		} else {
-		_cairo_output_stream_printf (stream,
+		    _cairo_output_stream_printf (stream,
-					     ">%d<",
+						 ">%d<",
-					     rounded_delta);
+						 rounded_delta);
+		}
+	    }
 	    /* Convert the rounded delta back to text
 	     * space before adding to the current text
 	     * position. */
 	    delta = rounded_delta/-1000.0;
 	    pdf_operators->cur_x += delta;
 	}
-	_cairo_output_stream_printf (stream,
-				     "%0*x",
+	_cairo_pdf_operators_emit_glyph_index (pdf_operators,
-				     pdf_operators->hex_width,
+					       stream,
-				     pdf_operators->glyphs[i].glyph_index);
+					       pdf_operators->glyphs[i].glyph_index);
 	pdf_operators->cur_x += pdf_operators->glyphs[i].x_advance;
+    }
-    _cairo_output_stream_printf (stream, ">]TJ\n");
+    _cairo_output_stream_printf (stream, "%s]TJ\n", pdf_operators->is_latin ? ")" : ">");
 	if (unlikely (status))
 	    return status;
+    }
     pdf_operators->font_id = subset_glyph->font_id;
     pdf_operators->subset_id = subset_glyph->subset_id;
+    pdf_operators->is_latin = subset_glyph->is_latin;
     if (subset_glyph->is_composite)
 	pdf_operators->hex_width = 4;
     else

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/cairo/src/cairo-pdf-operators.c – Rev 1897 → 3959