CairoOutputDev.cc 89.9 KB
Newer Older
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1 2 3 4 5 6 7 8
//========================================================================
//
// CairoOutputDev.cc
//
// Copyright 2003 Glyph & Cog, LLC
// Copyright 2004 Red Hat, Inc
//
//========================================================================
9 10 11 12 13

//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
14 15 16
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
17 18
// Copyright (C) 2005-2008 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2005, 2006 Kristian Høgsberg <krh@redhat.com>
19
// Copyright (C) 2005, 2009, 2012 Albert Astals Cid <aacid@kde.org>
20
// Copyright (C) 2005 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
21
// Copyright (C) 2006-2011 Carlos Garcia Campos <carlosgc@gnome.org>
22
// Copyright (C) 2008 Carl Worth <cworth@cworth.org>
Albert Astals Cid's avatar
Albert Astals Cid committed
23
// Copyright (C) 2008-2012 Adrian Johnson <ajohnson@redneon.com>
24
// Copyright (C) 2008 Michael Vrable <mvrable@cs.ucsd.edu>
Albert Astals Cid's avatar
Albert Astals Cid committed
25
// Copyright (C) 2008, 2009 Chris Wilson <chris@chris-wilson.co.uk>
26
// Copyright (C) 2008, 2012 Hib Eris <hib@hiberis.nl>
27
// Copyright (C) 2009, 2010 David Benjamin <davidben@mit.edu>
28
// Copyright (C) 2011, 2012 Thomas Freitag <Thomas.Freitag@alfa.de>
Albert Astals Cid's avatar
Albert Astals Cid committed
29
// Copyright (C) 2012 Patrick Pfeifer <p2000@mailinator.com>
Albert Astals Cid's avatar
Albert Astals Cid committed
30
// Copyright (C) 2012 Jason Crain <jason@aquaticape.us>
31 32 33 34 35
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
Kristian Høgsberg's avatar
Kristian Høgsberg committed
36 37 38 39 40 41 42 43 44

#include <config.h>

#ifdef USE_GCC_PRAGMAS
#pragma implementation
#endif

#include <string.h>
#include <math.h>
45
#include <assert.h>
Kristian Høgsberg's avatar
Kristian Høgsberg committed
46 47 48
#include <cairo.h>

#include "goo/gfile.h"
49
#include "goo/gtypes_p.h"
Kristian Høgsberg's avatar
Kristian Høgsberg committed
50 51 52
#include "GlobalParams.h"
#include "Error.h"
#include "Object.h"
53
#include "Gfx.h"
Kristian Høgsberg's avatar
Kristian Høgsberg committed
54 55
#include "GfxState.h"
#include "GfxFont.h"
56
#include "Page.h"
Kristian Høgsberg's avatar
Kristian Høgsberg committed
57 58
#include "Link.h"
#include "FontEncodingTables.h"
59
#include "PDFDocEncoding.h"
Kristian Høgsberg's avatar
Kristian Høgsberg committed
60 61 62 63
#include <fofi/FoFiTrueType.h>
#include <splash/SplashBitmap.h>
#include "CairoOutputDev.h"
#include "CairoFontEngine.h"
64
#include "CairoRescaleBox.h"
65
#include "UnicodeMap.h"
Kristian Høgsberg's avatar
Kristian Høgsberg committed
66 67
//------------------------------------------------------------------------

68
// #define LOG_CAIRO
Kristian Høgsberg's avatar
Kristian Høgsberg committed
69 70 71 72 73 74 75

#ifdef LOG_CAIRO
#define LOG(x) (x)
#else
#define LOG(x)
#endif

76 77 78 79 80 81
static inline void printMatrix(cairo_matrix_t *matrix){
	printf("%f %f, %f %f (%f %f)\n", matrix->xx, matrix->yx,
			matrix->xy, matrix->yy,
			matrix->x0, matrix->y0);
}

Adrian Johnson's avatar
Adrian Johnson committed
82 83 84 85 86

#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#define MAX(a,b) (((a) > (b)) ? (a) : (b))


87 88 89 90
//------------------------------------------------------------------------
// CairoImage
//------------------------------------------------------------------------

91 92
CairoImage::CairoImage (double x1, double y1, double x2, double y2) {
  this->image = NULL;
93 94 95 96 97 98 99 100 101 102
  this->x1 = x1;
  this->y1 = y1;
  this->x2 = x2;
  this->y2 = y2;
}

CairoImage::~CairoImage () {
  if (image)
    cairo_surface_destroy (image);
}
Kristian Høgsberg's avatar
Kristian Høgsberg committed
103

104 105 106 107 108 109
void CairoImage::setImage (cairo_surface_t *image) {
  if (this->image)
    cairo_surface_destroy (this->image);
  this->image = cairo_surface_reference (image);
}

Kristian Høgsberg's avatar
Kristian Høgsberg committed
110 111 112 113
//------------------------------------------------------------------------
// CairoOutputDev
//------------------------------------------------------------------------

114 115 116 117 118 119 120 121 122
// We cannot tie the lifetime of an FT_Library object to that of
// CairoOutputDev, since any FT_Faces created with it may end up with a
// reference by Cairo which can be held long after the CairoOutputDev is
// deleted.  The simplest way to avoid problems is to never tear down the
// FT_Library instance; to avoid leaks, just use a single global instance
// initialized the first time it is needed.
FT_Library CairoOutputDev::ft_lib;
GBool CairoOutputDev::ft_lib_initialized = gFalse;

123
CairoOutputDev::CairoOutputDev() {
124
  doc = NULL;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
125

126 127 128 129 130
  if (!ft_lib_initialized) {
    FT_Init_FreeType(&ft_lib);
    ft_lib_initialized = gTrue;
  }

Kristian Høgsberg's avatar
Kristian Høgsberg committed
131
  fontEngine = NULL;
132
  fontEngine_owner = gFalse;
133
  glyphs = NULL;
134
  fill_pattern = NULL;
135
  fill_color.r = fill_color.g = fill_color.b = 0;
136
  stroke_pattern = NULL;
137
  stroke_color.r = stroke_color.g = stroke_color.b = 0;
138 139
  stroke_opacity = 1.0;
  fill_opacity = 1.0;
140
  textClipPath = NULL;
Adrian Johnson's avatar
Adrian Johnson committed
141
  strokePathClip = NULL;
142
  cairo = NULL;
143
  currentFont = NULL;
144
  prescaleImages = gTrue;
145
  printing = gTrue;
146
  use_show_text_glyphs = gFalse;
147
  inType3Char = gFalse;
148
  t3_glyph_has_bbox = gFalse;
149 150

  groupColorSpaceStack = NULL;
151
  maskStack = NULL;
152 153
  group = NULL;
  mask = NULL;
154 155 156
  shape = NULL;
  cairo_shape = NULL;
  knockoutCount = 0;
157 158

  text = NULL;
159
  actualText = NULL;
160 161 162 163

  // the SA parameter supposedly defaults to false, but Acrobat
  // apparently hardwires it to true
  stroke_adjust = globalParams->getStrokeAdjust();
164 165
  align_stroke_coords = gFalse;
  adjusted_stroke_width = gFalse;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
166 167 168
}

CairoOutputDev::~CairoOutputDev() {
169
  if (fontEngine_owner && fontEngine) {
Kristian Høgsberg's avatar
Kristian Høgsberg committed
170 171
    delete fontEngine;
  }
172

173 174
  if (cairo)
    cairo_destroy (cairo);
175 176
  cairo_pattern_destroy (stroke_pattern);
  cairo_pattern_destroy (fill_pattern);
177 178
  if (group)
    cairo_pattern_destroy (group);
Chris Wilson's avatar
Chris Wilson committed
179 180
  if (mask)
    cairo_pattern_destroy (mask);
181 182
  if (shape)
    cairo_pattern_destroy (shape);
183
  if (text) 
184 185 186
    text->decRefCnt();
  if (actualText)
    delete actualText;  
187
}
Kristian Høgsberg's avatar
Kristian Høgsberg committed
188

189
void CairoOutputDev::setCairo(cairo_t *cairo)
190
{
191 192 193
  if (this->cairo != NULL) {
    cairo_status_t status = cairo_status (this->cairo);
    if (status) {
194
      error(errInternal, -1, "cairo context error: {0:s}\n", cairo_status_to_string(status));
195
    }
196
    cairo_destroy (this->cairo);
197
    assert(!cairo_shape);
198
  }
199
  if (cairo != NULL) {
200
    this->cairo = cairo_reference (cairo);
201 202 203 204
	/* save the initial matrix so that we can use it for type3 fonts. */
	//XXX: is this sufficient? could we miss changes to the matrix somehow?
	cairo_get_matrix(cairo, &orig_matrix);
  } else {
205
    this->cairo = NULL;
206
    this->cairo_shape = NULL;
207
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
208 209
}

210 211 212 213
void CairoOutputDev::setTextPage(TextPage *text)
{
  if (this->text) 
    this->text->decRefCnt();
214 215
  if (actualText)
    delete actualText;
216 217 218
  if (text) {
    this->text = text;
    this->text->incRefCnt();
219
    actualText = new ActualText(text);
220 221
  } else {
    this->text = NULL;
222
    actualText = NULL;
223 224 225
  }
}

226
void CairoOutputDev::startDoc(PDFDoc *docA,
227
			      CairoFontEngine *parentFontEngine) {
228
  doc = docA;
229 230 231 232 233 234 235 236
  if (parentFontEngine) {
    fontEngine = parentFontEngine;
  } else {
    if (fontEngine) {
      delete fontEngine;
    }
    fontEngine = new CairoFontEngine(ft_lib);
    fontEngine_owner = gTrue;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
237 238 239
  }
}

240 241 242 243
void CairoOutputDev::startPage(int pageNum, GfxState *state) {
  /* set up some per page defaults */
  cairo_pattern_destroy(fill_pattern);
  cairo_pattern_destroy(stroke_pattern);
244 245

  fill_pattern = cairo_pattern_create_rgb(0., 0., 0.);
246
  fill_color.r = fill_color.g = fill_color.b = 0;
247
  stroke_pattern = cairo_pattern_reference(fill_pattern);
248
  stroke_color.r = stroke_color.g = stroke_color.b = 0;
249 250 251 252 253 254 255 256

  if (text)
    text->startPage(state);
}

void CairoOutputDev::endPage() {
  if (text) {
    text->endPage();
257
    text->coalesce(gTrue, 0, gFalse);
258
  }
259 260
}

Kristian Høgsberg's avatar
Kristian Høgsberg committed
261 262 263
void CairoOutputDev::saveState(GfxState *state) {
  LOG(printf ("save\n"));
  cairo_save (cairo);
264 265
  if (cairo_shape)
      cairo_save (cairo_shape);
266 267 268

  MaskStack *ms = new MaskStack;
  ms->mask = cairo_pattern_reference(mask);
Adrian Johnson's avatar
Adrian Johnson committed
269
  ms->mask_matrix = mask_matrix;
270 271
  ms->next = maskStack;
  maskStack = ms;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
272 273 274 275 276
}

void CairoOutputDev::restoreState(GfxState *state) {
  LOG(printf ("restore\n"));
  cairo_restore (cairo);
277 278
  if (cairo_shape)
      cairo_restore (cairo_shape);
279 280 281 282 283 284 285

  /* These aren't restored by cairo_restore() since we keep them in
   * the output device. */
  updateFillColor(state);
  updateStrokeColor(state);
  updateFillOpacity(state);
  updateStrokeOpacity(state);
286
  updateBlendMode(state);
287 288

  MaskStack* ms = maskStack;
289
  if (ms) {
290 291
    if (mask)
      cairo_pattern_destroy(mask);
292
    mask = ms->mask;
Adrian Johnson's avatar
Adrian Johnson committed
293
    mask_matrix = ms->mask_matrix;
294 295 296
    maskStack = ms->next;
    delete ms;
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
297 298 299 300 301 302 303 304 305 306 307
}

void CairoOutputDev::updateAll(GfxState *state) {
  updateLineDash(state);
  updateLineJoin(state);
  updateLineCap(state);
  updateLineWidth(state);
  updateFlatness(state);
  updateMiterLimit(state);
  updateFillColor(state);
  updateStrokeColor(state);
308 309
  updateFillOpacity(state);
  updateStrokeOpacity(state);
310
  updateBlendMode(state);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
311
  needFontUpdate = gTrue;
312 313
  if (text)
    text->updateFont(state);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
314 315
}

316 317 318 319 320 321 322 323 324
void CairoOutputDev::setDefaultCTM(double *ctm) {
  cairo_matrix_t matrix;
  matrix.xx = ctm[0];
  matrix.yx = ctm[1];
  matrix.xy = ctm[2];
  matrix.yy = ctm[3];
  matrix.x0 = ctm[4];
  matrix.y0 = ctm[5];

325
  cairo_transform (cairo, &matrix);
326
  if (cairo_shape)
327
      cairo_transform (cairo_shape, &matrix);
328 329 330 331

  OutputDev::setDefaultCTM(ctm);
}

Kristian Høgsberg's avatar
Kristian Høgsberg committed
332 333 334
void CairoOutputDev::updateCTM(GfxState *state, double m11, double m12,
				double m21, double m22,
				double m31, double m32) {
335
  cairo_matrix_t matrix, invert_matrix;
336 337 338 339 340 341 342
  matrix.xx = m11;
  matrix.yx = m12;
  matrix.xy = m21;
  matrix.yy = m22;
  matrix.x0 = m31;
  matrix.y0 = m32;

343 344 345 346 347 348 349 350
  /* Make sure the matrix is invertible before setting it.
   * cairo will blow up if we give it a matrix that's not
   * invertible, so we need to check before passing it
   * to cairo_transform. Ignoring it is likely to give better
   * results than not rendering anything at all. See #14398
   *
   * Ideally, we could do the cairo_transform
   * and then check if anything went wrong and fix it then
351 352 353
   * instead of having to invert the matrix. */
  invert_matrix = matrix;
  if (cairo_matrix_invert(&invert_matrix)) {
354
    error(errSyntaxWarning, -1, "matrix not invertible\n");
355 356 357
    return;
  }

358
  cairo_transform (cairo, &matrix);
359 360
  if (cairo_shape)
    cairo_transform (cairo_shape, &matrix);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
361 362 363 364 365 366 367 368 369 370 371 372
  updateLineDash(state);
  updateLineJoin(state);
  updateLineCap(state);
  updateLineWidth(state);
}

void CairoOutputDev::updateLineDash(GfxState *state) {
  double *dashPattern;
  int dashLength;
  double dashStart;

  state->getLineDash(&dashPattern, &dashLength, &dashStart);
373
  cairo_set_dash (cairo, dashPattern, dashLength, dashStart);
374 375
  if (cairo_shape)
    cairo_set_dash (cairo_shape, dashPattern, dashLength, dashStart);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
376 377 378
}

void CairoOutputDev::updateFlatness(GfxState *state) {
379
  // cairo_set_tolerance (cairo, state->getFlatness());
Kristian Høgsberg's avatar
Kristian Høgsberg committed
380 381 382 383 384 385 386 387 388 389 390 391 392 393
}

void CairoOutputDev::updateLineJoin(GfxState *state) {
  switch (state->getLineJoin()) {
  case 0:
    cairo_set_line_join (cairo, CAIRO_LINE_JOIN_MITER);
    break;
  case 1:
    cairo_set_line_join (cairo, CAIRO_LINE_JOIN_ROUND);
    break;
  case 2:
    cairo_set_line_join (cairo, CAIRO_LINE_JOIN_BEVEL);
    break;
  }
394 395
  if (cairo_shape)
    cairo_set_line_join (cairo_shape, cairo_get_line_join(cairo));
Kristian Høgsberg's avatar
Kristian Høgsberg committed
396 397 398 399 400 401 402 403 404 405 406 407 408 409
}

void CairoOutputDev::updateLineCap(GfxState *state) {
  switch (state->getLineCap()) {
  case 0:
    cairo_set_line_cap (cairo, CAIRO_LINE_CAP_BUTT);
    break;
  case 1:
    cairo_set_line_cap (cairo, CAIRO_LINE_CAP_ROUND);
    break;
  case 2:
    cairo_set_line_cap (cairo, CAIRO_LINE_CAP_SQUARE);
    break;
  }
410 411
  if (cairo_shape)
    cairo_set_line_cap (cairo_shape, cairo_get_line_cap(cairo));
Kristian Høgsberg's avatar
Kristian Høgsberg committed
412 413 414 415
}

void CairoOutputDev::updateMiterLimit(GfxState *state) {
  cairo_set_miter_limit (cairo, state->getMiterLimit());
416 417
  if (cairo_shape)
    cairo_set_miter_limit (cairo_shape, state->getMiterLimit());
Kristian Høgsberg's avatar
Kristian Høgsberg committed
418 419 420
}

void CairoOutputDev::updateLineWidth(GfxState *state) {
421
  LOG(printf ("line width: %f\n", state->getLineWidth()));
422
  adjusted_stroke_width = gFalse;
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
  double width = state->getLineWidth();
  if (stroke_adjust && !printing) {
    double x, y;
    x = y = width;

    /* find out line width in device units */
    cairo_user_to_device_distance(cairo, &x, &y);
    if (fabs(x) <= 1.0 && fabs(y) <= 1.0) {
      /* adjust width to at least one device pixel */
      x = y = 1.0;
      cairo_device_to_user_distance(cairo, &x, &y);
      width = MIN(fabs(x),fabs(y));
      adjusted_stroke_width = gTrue;
    }
  } else if (width == 0.0) {
    /* Cairo does not support 0 line width == 1 device pixel. Find out
     * how big pixels (device unit) are in the x and y
     * directions. Choose the smaller of the two as our line width.
     */
442
    double x = 1.0, y = 1.0;
443 444 445 446 447
    if (printing) {
      // assume printer pixel size is 1/600 inch
      x = 72.0/600;
      y = 72.0/600;
    }
448
    cairo_device_to_user_distance(cairo, &x, &y);
449
    width = MIN(fabs(x),fabs(y));
450
  }
451
  cairo_set_line_width (cairo, width);
452 453
  if (cairo_shape)
    cairo_set_line_width (cairo_shape, cairo_get_line_width (cairo));
Kristian Høgsberg's avatar
Kristian Høgsberg committed
454 455 456
}

void CairoOutputDev::updateFillColor(GfxState *state) {
457
  GfxRGB color = fill_color;
458

459
  state->getFillRGB(&fill_color);
460 461
  if (cairo_pattern_get_type (fill_pattern) != CAIRO_PATTERN_TYPE_SOLID ||
      color.r != fill_color.r ||
462 463 464 465
      color.g != fill_color.g ||
      color.b != fill_color.b)
  {
    cairo_pattern_destroy(fill_pattern);
466 467 468
    fill_pattern = cairo_pattern_create_rgba(colToDbl(fill_color.r),
					     colToDbl(fill_color.g),
					     colToDbl(fill_color.b),
469 470 471 472 473
					     fill_opacity);

    LOG(printf ("fill color: %d %d %d\n",
		fill_color.r, fill_color.g, fill_color.b));
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
474 475 476
}

void CairoOutputDev::updateStrokeColor(GfxState *state) {
477
  GfxRGB color = stroke_color;
478

479
  state->getStrokeRGB(&stroke_color);
480 481
  if (cairo_pattern_get_type (fill_pattern) != CAIRO_PATTERN_TYPE_SOLID ||
      color.r != stroke_color.r ||
482 483 484 485
      color.g != stroke_color.g ||
      color.b != stroke_color.b)
  {
    cairo_pattern_destroy(stroke_pattern);
486 487 488
    stroke_pattern = cairo_pattern_create_rgba(colToDbl(stroke_color.r),
					       colToDbl(stroke_color.g),
					       colToDbl(stroke_color.b),
489 490 491 492 493
					       stroke_opacity);

    LOG(printf ("stroke color: %d %d %d\n",
		stroke_color.r, stroke_color.g, stroke_color.b));
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
494 495
}

496
void CairoOutputDev::updateFillOpacity(GfxState *state) {
497
  double opacity = fill_opacity;
498

499 500 501
  fill_opacity = state->getFillOpacity();
  if (opacity != fill_opacity) {
    cairo_pattern_destroy(fill_pattern);
502 503 504
    fill_pattern = cairo_pattern_create_rgba(colToDbl(fill_color.r),
					     colToDbl(fill_color.g),
					     colToDbl(fill_color.b),
505 506 507 508
					     fill_opacity);

    LOG(printf ("fill opacity: %f\n", fill_opacity));
  }
509 510 511
}

void CairoOutputDev::updateStrokeOpacity(GfxState *state) {
512
  double opacity = stroke_opacity;
513

514 515 516
  stroke_opacity = state->getStrokeOpacity();
  if (opacity != stroke_opacity) {
    cairo_pattern_destroy(stroke_pattern);
517 518 519
    stroke_pattern = cairo_pattern_create_rgba(colToDbl(stroke_color.r),
					       colToDbl(stroke_color.g),
					       colToDbl(stroke_color.b),
520 521 522 523
					       stroke_opacity);

    LOG(printf ("stroke opacity: %f\n", stroke_opacity));
  }
524 525
}

526 527 528 529
void CairoOutputDev::updateFillColorStop(GfxState *state, double offset) {
  state->getFillRGB(&fill_color);

  cairo_pattern_add_color_stop_rgba(fill_pattern, offset,
530 531 532
				    colToDbl(fill_color.r),
				    colToDbl(fill_color.g),
				    colToDbl(fill_color.b),
533 534 535 536 537
				    fill_opacity);
  LOG(printf ("fill color stop: %f (%d, %d, %d)\n",
	      offset, fill_color.r, fill_color.g, fill_color.b));
}

538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
void CairoOutputDev::updateBlendMode(GfxState *state) {
  switch (state->getBlendMode()) {
  default:
  case gfxBlendNormal:
    cairo_set_operator (cairo, CAIRO_OPERATOR_OVER);
    break;
  case gfxBlendMultiply:
    cairo_set_operator (cairo, CAIRO_OPERATOR_MULTIPLY);
    break;
  case gfxBlendScreen:
    cairo_set_operator (cairo, CAIRO_OPERATOR_SCREEN);
    break;
  case gfxBlendOverlay:
    cairo_set_operator (cairo, CAIRO_OPERATOR_OVERLAY);
    break;
  case gfxBlendDarken:
    cairo_set_operator (cairo, CAIRO_OPERATOR_DARKEN);
    break;
  case gfxBlendLighten:
    cairo_set_operator (cairo, CAIRO_OPERATOR_LIGHTEN);
    break;
  case gfxBlendColorDodge:
    cairo_set_operator (cairo, CAIRO_OPERATOR_COLOR_DODGE);
    break;
  case gfxBlendColorBurn:
    cairo_set_operator (cairo, CAIRO_OPERATOR_COLOR_BURN);
    break;
  case gfxBlendHardLight:
    cairo_set_operator (cairo, CAIRO_OPERATOR_HARD_LIGHT);
    break;
  case gfxBlendSoftLight:
    cairo_set_operator (cairo, CAIRO_OPERATOR_SOFT_LIGHT);
    break;
  case gfxBlendDifference:
    cairo_set_operator (cairo, CAIRO_OPERATOR_DIFFERENCE);
    break;
  case gfxBlendExclusion:
    cairo_set_operator (cairo, CAIRO_OPERATOR_EXCLUSION);
    break;
  case gfxBlendHue:
    cairo_set_operator (cairo, CAIRO_OPERATOR_HSL_HUE);
    break;
  case gfxBlendSaturation:
    cairo_set_operator (cairo, CAIRO_OPERATOR_HSL_SATURATION);
    break;
  case gfxBlendColor:
    cairo_set_operator (cairo, CAIRO_OPERATOR_HSL_COLOR);
    break;
  case gfxBlendLuminosity:
    cairo_set_operator (cairo, CAIRO_OPERATOR_HSL_LUMINOSITY);
    break;
  }
  LOG(printf ("blend mode: %d\n", (int)state->getBlendMode()));
}

Kristian Høgsberg's avatar
Kristian Høgsberg committed
593
void CairoOutputDev::updateFont(GfxState *state) {
594
  cairo_font_face_t *font_face;
595
  cairo_matrix_t matrix, invert_matrix;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
596 597

  LOG(printf ("updateFont() font=%s\n", state->getFont()->getName()->getCString()));
598

Kristian Høgsberg's avatar
Kristian Høgsberg committed
599 600
  needFontUpdate = gFalse;

601 602 603 604
  //FIXME: use cairo font engine?
  if (text)
    text->updateFont(state);
  
605
  currentFont = fontEngine->getFont (state->getFont(), doc, printing);
606

607 608
  if (!currentFont)
    return;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
609

610 611
  font_face = currentFont->getFontFace();
  cairo_set_font_face (cairo, font_face);
612 613 614

  use_show_text_glyphs = state->getFont()->hasToUnicodeCMap() &&
    cairo_surface_has_show_text_glyphs (cairo_get_target (cairo));
615 616 617
 
  double fontSize = state->getFontSize();
  double *m = state->getTextMat();
618 619 620 621 622 623
  /* NOTE: adjusting by a constant is hack. The correct solution
   * is probably to use user-fonts and compute the scale on a per
   * glyph basis instead of for the entire font */
  double w = currentFont->getSubstitutionCorrection(state->getFont());
  matrix.xx = m[0] * fontSize * state->getHorizScaling() * w;
  matrix.yx = m[1] * fontSize * state->getHorizScaling() * w;
624 625
  matrix.xy = -m[2] * fontSize;
  matrix.yy = -m[3] * fontSize;
626 627
  matrix.x0 = 0;
  matrix.y0 = 0;
628

629 630
  LOG(printf ("font matrix: %f %f %f %f\n", matrix.xx, matrix.yx, matrix.xy, matrix.yy));

631 632 633 634 635 636 637 638
 /* Make sure the font matrix is invertible before setting it.  cairo
  * will blow up if we give it a matrix that's not invertible, so we
  * need to check before passing it to cairo_set_font_matrix. Ignoring it
  * is likely to give better results than not rendering anything at
  * all. See #18254.
  */
  invert_matrix = matrix;
  if (cairo_matrix_invert(&invert_matrix)) {
639
    error(errSyntaxWarning, -1, "font matrix not invertible\n");
640 641 642
    return;
  }

643
  cairo_set_font_matrix (cairo, &matrix);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
644 645
}

646 647 648 649 650 651 652
/* Tolerance in pixels for checking if strokes are horizontal or vertical
 * lines in device space */
#define STROKE_COORD_TOLERANCE 0.5

/* Align stroke coordinate i if the point is the start or end of a
 * horizontal or vertical line */
void CairoOutputDev::alignStrokeCoords(GfxSubpath *subpath, int i, double *x, double *y)
653
{
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
  double x1, y1, x2, y2;
  GBool align = gFalse;

  x1 = subpath->getX(i);
  y1 = subpath->getY(i);
  cairo_user_to_device (cairo, &x1, &y1);

  // Does the current coord and prev coord form a horiz or vert line?
  if (i > 0 && !subpath->getCurve(i - 1)) {
    x2 = subpath->getX(i - 1);
    y2 = subpath->getY(i - 1);
    cairo_user_to_device (cairo, &x2, &y2);
    if (fabs(x2 - x1) < STROKE_COORD_TOLERANCE || fabs(y2 - y1) < STROKE_COORD_TOLERANCE)
      align = gTrue;
  }

  // Does the current coord and next coord form a horiz or vert line?
  if (i < subpath->getNumPoints() - 1 && !subpath->getCurve(i + 1)) {
    x2 = subpath->getX(i + 1);
    y2 = subpath->getY(i + 1);
    cairo_user_to_device (cairo, &x2, &y2);
    if (fabs(x2 - x1) < STROKE_COORD_TOLERANCE || fabs(y2 - y1) < STROKE_COORD_TOLERANCE)
      align = gTrue;
  }

  *x = subpath->getX(i);
  *y = subpath->getY(i);
  if (align) {
    /* see http://www.cairographics.org/FAQ/#sharp_lines */
    cairo_user_to_device (cairo, x, y);
    *x = floor(*x) + 0.5;
    *y = floor(*y) + 0.5;
    cairo_device_to_user (cairo, x, y);
  }
688 689
}

690 691
#undef STROKE_COORD_TOLERANCE

692
void CairoOutputDev::doPath(cairo_t *cairo, GfxState *state, GfxPath *path) {
Kristian Høgsberg's avatar
Kristian Høgsberg committed
693 694
  GfxSubpath *subpath;
  int i, j;
695
  double x, y;
696
  cairo_new_path (cairo);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
697 698 699
  for (i = 0; i < path->getNumSubpaths(); ++i) {
    subpath = path->getSubpath(i);
    if (subpath->getNumPoints() > 0) {
700
      if (align_stroke_coords) {
701
        alignStrokeCoords(subpath, 0, &x, &y);
702
      } else {
703 704
        x = subpath->getX(0);
        y = subpath->getY(0);
705
      }
706
      cairo_move_to (cairo, x, y);
707
      j = 1;
Kristian Høgsberg's avatar
Kristian Høgsberg committed
708 709
      while (j < subpath->getNumPoints()) {
	if (subpath->getCurve(j)) {
710 711 712 713 714 715
	  if (align_stroke_coords) {
            alignStrokeCoords(subpath, j + 2, &x, &y);
          } else {
            x = subpath->getX(j+2);
            y = subpath->getY(j+2);
          }
716 717 718
	  cairo_curve_to( cairo,
			  subpath->getX(j), subpath->getY(j),
			  subpath->getX(j+1), subpath->getY(j+1),
719
			  x, y);
720

Kristian Høgsberg's avatar
Kristian Høgsberg committed
721 722
	  j += 3;
	} else {
723
	  if (align_stroke_coords) {
724 725 726 727 728 729
            alignStrokeCoords(subpath, j, &x, &y);
          } else {
            x = subpath->getX(j);
            y = subpath->getY(j);
          }
          cairo_line_to (cairo, x, y);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
730 731 732 733 734 735 736 737 738 739 740 741
	  ++j;
	}
      }
      if (subpath->isClosed()) {
	LOG (printf ("close\n"));
	cairo_close_path (cairo);
      }
    }
  }
}

void CairoOutputDev::stroke(GfxState *state) {
742 743 744 745 746 747 748
  if (inType3Char) {
      GfxGray gray;
      state->getFillGray(&gray);
      if (colToDbl(gray) > 0.5)
	  return;
  }

749 750
  if (adjusted_stroke_width)
    align_stroke_coords = gTrue;
751
  doPath (cairo, state, state->getPath());
752
  align_stroke_coords = gFalse;
753
  cairo_set_source (cairo, stroke_pattern);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
754 755
  LOG(printf ("stroke\n"));
  cairo_stroke (cairo);
756 757 758 759
  if (cairo_shape) {
    doPath (cairo_shape, state, state->getPath());
    cairo_stroke (cairo_shape);
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
760 761 762
}

void CairoOutputDev::fill(GfxState *state) {
763 764 765 766 767 768 769
  if (inType3Char) {
      GfxGray gray;
      state->getFillGray(&gray);
      if (colToDbl(gray) > 0.5)
	  return;
  }

770
  doPath (cairo, state, state->getPath());
Kristian Høgsberg's avatar
Kristian Høgsberg committed
771
  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_WINDING);
772
  cairo_set_source (cairo, fill_pattern);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
773
  LOG(printf ("fill\n"));
774
  //XXX: how do we get the path
775
  if (mask) {
Adrian Johnson's avatar
Adrian Johnson committed
776
    cairo_save (cairo);
777
    cairo_clip (cairo);
Adrian Johnson's avatar
Adrian Johnson committed
778
    cairo_set_matrix (cairo, &mask_matrix);
779
    cairo_mask (cairo, mask);
Adrian Johnson's avatar
Adrian Johnson committed
780
    cairo_restore (cairo);
Adrian Johnson's avatar
Adrian Johnson committed
781
  } else if (strokePathClip) {
782
    fillToStrokePathClip(state);
783 784 785
  } else {
    cairo_fill (cairo);
  }
786 787 788 789 790
  if (cairo_shape) {
    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_WINDING);
    doPath (cairo_shape, state, state->getPath());
    cairo_fill (cairo_shape);
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
791 792 793
}

void CairoOutputDev::eoFill(GfxState *state) {
794
  doPath (cairo, state, state->getPath());
Kristian Høgsberg's avatar
Kristian Høgsberg committed
795
  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_EVEN_ODD);
796
  cairo_set_source (cairo, fill_pattern);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
797 798
  LOG(printf ("fill-eo\n"));
  cairo_fill (cairo);
799 800 801 802 803 804 805

  if (cairo_shape) {
    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_EVEN_ODD);
    doPath (cairo_shape, state, state->getPath());
    cairo_fill (cairo_shape);
  }

Kristian Høgsberg's avatar
Kristian Høgsberg committed
806 807
}

808
GBool CairoOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx1, Catalog *cat, Object *str,
809
					double *pmat, int paintType, int /*tilingType*/, Dict *resDict,
810 811 812 813 814 815 816 817 818 819 820
					double *mat, double *bbox,
					int x0, int y0, int x1, int y1,
					double xStep, double yStep)
{
  PDFRectangle box;
  Gfx *gfx;
  cairo_pattern_t *pattern;
  cairo_surface_t *surface;
  cairo_matrix_t matrix;
  cairo_t *old_cairo;
  double xMin, yMin, xMax, yMax;
821
  double width, height;
822
  int surface_width, surface_height;
Adrian Johnson's avatar
Adrian Johnson committed
823
  StrokePathClip *strokePathTmp;
824

825 826 827 828
  width = bbox[2] - bbox[0];
  height = bbox[3] - bbox[1];

  if (xStep != width || yStep != height)
829 830 831
    return gFalse;
  /* TODO: implement the other cases here too */

832 833 834
  surface_width = (int) ceil (width);
  surface_height = (int) ceil (height);

835 836
  surface = cairo_surface_create_similar (cairo_get_target (cairo),
					  CAIRO_CONTENT_COLOR_ALPHA,
837
					  surface_width, surface_height);
838 839 840 841 842 843 844 845 846
  if (cairo_surface_status (surface))
    return gFalse;

  old_cairo = cairo;
  cairo = cairo_create (surface);
  cairo_surface_destroy (surface);

  box.x1 = bbox[0]; box.y1 = bbox[1];
  box.x2 = bbox[2]; box.y2 = bbox[3];
Adrian Johnson's avatar
Adrian Johnson committed
847 848
  strokePathTmp = strokePathClip;
  strokePathClip = NULL;
849
  gfx = new Gfx(doc, this, resDict, &box, NULL);
850 851
  gfx->display(str);
  delete gfx;
Adrian Johnson's avatar
Adrian Johnson committed
852
  strokePathClip = strokePathTmp;
853 854 855 856 857 858 859 860 861 862

  pattern = cairo_pattern_create_for_surface (cairo_get_target (cairo));
  cairo_destroy (cairo);
  cairo = old_cairo;
  if (cairo_pattern_status (pattern))
    return gFalse;

  state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
  cairo_rectangle (cairo, xMin, yMin, xMax - xMin, yMax - yMin);

863
  cairo_matrix_init_scale (&matrix, surface_width / width, surface_height / height);
864 865
  cairo_pattern_set_matrix (pattern, &matrix);

866 867 868 869
  cairo_matrix_init (&matrix, mat[0], mat[1], mat[2], mat[3], mat[4], mat[5]);
  cairo_transform (cairo, &matrix);
  cairo_set_source (cairo, pattern);
  cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
Adrian Johnson's avatar
Adrian Johnson committed
870
  if (strokePathClip) {
871
    fillToStrokePathClip(state);
Adrian Johnson's avatar
Adrian Johnson committed
872 873 874
  } else {
    cairo_fill (cairo);
  }
875 876 877 878 879 880

  cairo_pattern_destroy (pattern);

  return gTrue;
}

881 882 883 884 885 886 887 888 889 890 891
GBool CairoOutputDev::axialShadedFill(GfxState *state, GfxAxialShading *shading, double tMin, double tMax) {
  double x0, y0, x1, y1;
  double dx, dy;

  shading->getCoords(&x0, &y0, &x1, &y1);
  dx = x1 - x0;
  dy = y1 - y0;

  cairo_pattern_destroy(fill_pattern);
  fill_pattern = cairo_pattern_create_linear (x0 + tMin * dx, y0 + tMin * dy,
					      x0 + tMax * dx, y0 + tMax * dy);
892 893 894 895
  if (!shading->getExtend0() && !shading->getExtend1())
    cairo_pattern_set_extend (fill_pattern, CAIRO_EXTEND_NONE);
  else
    cairo_pattern_set_extend (fill_pattern, CAIRO_EXTEND_PAD);
896

897 898
  LOG (printf ("axial-sh\n"));

899 900 901 902 903
  // TODO: use the actual stops in the shading in the case
  // of linear interpolation (Type 2 Exponential functions with N=1)
  return gFalse;
}

904 905 906 907 908
GBool CairoOutputDev::axialShadedSupportExtend(GfxState *state, GfxAxialShading *shading)
{
  return (shading->getExtend0() == shading->getExtend1());
}

909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
GBool CairoOutputDev::radialShadedFill(GfxState *state, GfxRadialShading *shading, double sMin, double sMax) {
  double x0, y0, r0, x1, y1, r1;
  double dx, dy, dr;

  shading->getCoords(&x0, &y0, &r0, &x1, &y1, &r1);
  dx = x1 - x0;
  dy = y1 - y0;
  dr = r1 - r0;
  cairo_pattern_destroy(fill_pattern);
  fill_pattern = cairo_pattern_create_radial (x0 + sMin * dx,
					      y0 + sMin * dy,
					      r0 + sMin * dr,
					      x0 + sMax * dx,
					      y0 + sMax * dy,
					      r0 + sMax * dr);
  if (shading->getExtend0() && shading->getExtend1())
    cairo_pattern_set_extend (fill_pattern, CAIRO_EXTEND_PAD);
  else
    cairo_pattern_set_extend (fill_pattern, CAIRO_EXTEND_NONE);

929 930
  LOG (printf ("radial-sh\n"));

931 932 933 934 935 936 937 938
  return gFalse;
}

GBool CairoOutputDev::radialShadedSupportExtend(GfxState *state, GfxRadialShading *shading)
{
  return (shading->getExtend0() == shading->getExtend1());
}

939
#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
940 941 942 943 944 945 946 947 948 949 950
GBool CairoOutputDev::gouraudTriangleShadedFill(GfxState *state, GfxGouraudTriangleShading *shading)
{
  double x0, y0, x1, y1, x2, y2;
  GfxColor color[3];
  int i, j;
  GfxRGB rgb;

  cairo_pattern_destroy(fill_pattern);
  fill_pattern = cairo_pattern_create_mesh ();

  for (i = 0; i < shading->getNTriangles(); i++) {
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965
    if (shading->isParameterized()) {
      double color0, color1, color2;
      shading->getTriangle(i, &x0, &y0, &color0,
                              &x1, &y1, &color1,
                              &x2, &y2, &color2);
      shading->getParameterizedColor(color0, &color[0]);
      shading->getParameterizedColor(color1, &color[1]);
      shading->getParameterizedColor(color2, &color[2]);
    } else {
      shading->getTriangle(i,
                           &x0, &y0, &color[0],
                           &x1, &y1, &color[1],
                           &x2, &y2, &color[2]);

    }
966

967
    cairo_mesh_pattern_begin_patch (fill_pattern);
968

969 970 971
    cairo_mesh_pattern_move_to (fill_pattern, x0, y0);
    cairo_mesh_pattern_line_to (fill_pattern, x1, y1);
    cairo_mesh_pattern_line_to (fill_pattern, x2, y2);
972 973 974

    for (j = 0; j < 3; j++) {
	shading->getColorSpace()->getRGB(&color[j], &rgb);
975
	cairo_mesh_pattern_set_corner_color_rgb (fill_pattern, j,
976 977 978 979 980
						 colToDbl(rgb.r),
						 colToDbl(rgb.g),
						 colToDbl(rgb.b));
    }

981
    cairo_mesh_pattern_end_patch (fill_pattern);
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
  }

  double xMin, yMin, xMax, yMax;
  // get the clip region bbox
  state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
  state->moveTo(xMin, yMin);
  state->lineTo(xMin, yMax);
  state->lineTo(xMax, yMax);
  state->lineTo(xMax, yMin);
  state->closePath();
  fill(state);
  state->clearPath();

  return gTrue;
}

GBool CairoOutputDev::patchMeshShadedFill(GfxState *state, GfxPatchMeshShading *shading)
{
  int i, j, k;

  cairo_pattern_destroy(fill_pattern);
  fill_pattern = cairo_pattern_create_mesh ();

  for (i = 0; i < shading->getNPatches(); i++) {
    GfxPatch *patch = shading->getPatch(i);
    GfxColor color;
    GfxRGB rgb;

1010
    cairo_mesh_pattern_begin_patch (fill_pattern);
1011

1012 1013
    cairo_mesh_pattern_move_to (fill_pattern, patch->x[0][0], patch->y[0][0]);
    cairo_mesh_pattern_curve_to (fill_pattern,
1014 1015 1016 1017
			    patch->x[0][1], patch->y[0][1],
			    patch->x[0][2], patch->y[0][2],
			    patch->x[0][3], patch->y[0][3]);

1018
    cairo_mesh_pattern_curve_to (fill_pattern,
1019 1020 1021 1022
			    patch->x[1][3], patch->y[1][3],
			    patch->x[2][3], patch->y[2][3],
			    patch->x[3][3], patch->y[3][3]);

1023
    cairo_mesh_pattern_curve_to (fill_pattern,
1024 1025 1026 1027
			    patch->x[3][2], patch->y[3][2],
			    patch->x[3][1], patch->y[3][1],
			    patch->x[3][0], patch->y[3][0]);

1028
    cairo_mesh_pattern_curve_to (fill_pattern,
1029 1030 1031 1032
			    patch->x[2][0], patch->y[2][0],
			    patch->x[1][0], patch->y[1][0],
			    patch->x[0][0], patch->y[0][0]);

1033 1034 1035 1036
    cairo_mesh_pattern_set_control_point (fill_pattern, 0, patch->x[1][1], patch->y[1][1]);
    cairo_mesh_pattern_set_control_point (fill_pattern, 1, patch->x[1][2], patch->y[1][2]);
    cairo_mesh_pattern_set_control_point (fill_pattern, 2, patch->x[2][2], patch->y[2][2]);
    cairo_mesh_pattern_set_control_point (fill_pattern, 3, patch->x[2][1], patch->y[2][1]);
1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065

    for (j = 0; j < 4; j++) {
      int u, v;

      switch (j) {
	case 0:
	  u = 0; v = 0;
	  break;
	case 1:
	  u = 0; v = 1;
	  break;
	case 2:
	  u = 1; v = 1;
	  break;
	case 3:
	  u = 1; v = 0;
	  break;
      }

      if (shading->isParameterized()) {
	shading->getParameterizedColor (patch->color[u][v].c[0], &color);
      } else {
	for (k = 0; k < shading->getColorSpace()->getNComps(); k++) {
          // simply cast to the desired type; that's all what is needed.
	  color.c[k] = GfxColorComp (patch->color[u][v].c[k]);
	}
      }

      shading->getColorSpace()->getRGB(&color, &rgb);
1066
      cairo_mesh_pattern_set_corner_color_rgb (fill_pattern, j,
1067 1068 1069 1070
					       colToDbl(rgb.r),
					       colToDbl(rgb.g),
					       colToDbl(rgb.b));
    }
1071
    cairo_mesh_pattern_end_patch (fill_pattern);
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
  }

  double xMin, yMin, xMax, yMax;
  // get the clip region bbox
  state->getUserClipBBox(&xMin, &yMin, &xMax, &yMax);
  state->moveTo(xMin, yMin);
  state->lineTo(xMin, yMax);
  state->lineTo(xMax, yMax);
  state->lineTo(xMax, yMin);
  state->closePath();
  fill(state);
  state->clearPath();

  return gTrue;
}
1087
#endif /* CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0) */
1088

1089
void CairoOutputDev::clip(GfxState *state) {
1090
  doPath (cairo, state, state->getPath());
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1091 1092 1093
  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_WINDING);
  cairo_clip (cairo);
  LOG (printf ("clip\n"));
1094 1095 1096 1097 1098
  if (cairo_shape) {
    doPath (cairo_shape, state, state->getPath());
    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_WINDING);
    cairo_clip (cairo_shape);
  }
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1099 1100 1101
}

void CairoOutputDev::eoClip(GfxState *state) {
1102
  doPath (cairo, state, state->getPath());
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1103 1104 1105
  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_EVEN_ODD);
  cairo_clip (cairo);
  LOG (printf ("clip-eo\n"));
1106 1107 1108 1109 1110 1111
  if (cairo_shape) {
    doPath (cairo_shape, state, state->getPath());
    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_EVEN_ODD);
    cairo_clip (cairo_shape);
  }

Kristian Høgsberg's avatar
Kristian Høgsberg committed
1112 1113
}

1114 1115
void CairoOutputDev::clipToStrokePath(GfxState *state) {
  LOG(printf("clip-to-stroke-path\n"));
Adrian Johnson's avatar
Adrian Johnson committed
1116
  strokePathClip = (StrokePathClip*)gmalloc (sizeof(*strokePathClip));
1117
  strokePathClip->path = state->getPath()->copy();
Adrian Johnson's avatar
Adrian Johnson committed
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
  cairo_get_matrix (cairo, &strokePathClip->ctm);
  strokePathClip->line_width = cairo_get_line_width (cairo);
  strokePathClip->dash_count = cairo_get_dash_count (cairo);
  if (strokePathClip->dash_count) {
    strokePathClip->dashes = (double*) gmallocn (sizeof(double), strokePathClip->dash_count);
    cairo_get_dash (cairo, strokePathClip->dashes, &strokePathClip->dash_offset);
  } else {
    strokePathClip->dashes = NULL;
  }
  strokePathClip->cap = cairo_get_line_cap (cairo);
  strokePathClip->join = cairo_get_line_join (cairo);
  strokePathClip->miter = cairo_get_miter_limit (cairo);
}

1132
void CairoOutputDev::fillToStrokePathClip(GfxState *state) {
Adrian Johnson's avatar
Adrian Johnson committed
1133 1134 1135 1136 1137 1138 1139 1140 1141
  cairo_save (cairo);

  cairo_set_matrix (cairo, &strokePathClip->ctm);
  cairo_set_line_width (cairo, strokePathClip->line_width);
  strokePathClip->dash_count = cairo_get_dash_count (cairo);
  cairo_set_dash (cairo, strokePathClip->dashes, strokePathClip->dash_count, strokePathClip->dash_offset);
  cairo_set_line_cap (cairo, strokePathClip->cap);
  cairo_set_line_join (cairo, strokePathClip->join);
  cairo_set_miter_limit (cairo, strokePathClip->miter);
1142
  doPath (cairo, state, strokePathClip->path);
Adrian Johnson's avatar
Adrian Johnson committed
1143 1144 1145 1146
  cairo_stroke (cairo);

  cairo_restore (cairo);

1147
  delete strokePathClip->path;
Adrian Johnson's avatar
Adrian Johnson committed
1148 1149 1150 1151
  if (strokePathClip->dashes)
    gfree (strokePathClip->dashes);
  gfree (strokePathClip);
  strokePathClip = NULL;
1152 1153
}

1154
void CairoOutputDev::beginString(GfxState *state, GooString *s)
1155 1156
{
  int len = s->getLength();
1157

1158 1159 1160
  if (needFontUpdate)
    updateFont(state);

1161 1162 1163
  if (!currentFont)
    return;

1164
  glyphs = (cairo_glyph_t *) gmallocn (len, sizeof (cairo_glyph_t));
1165
  glyphCount = 0;
1166
  if (use_show_text_glyphs) {
1167 1168 1169 1170 1171 1172
    clusters = (cairo_text_cluster_t *) gmallocn (len, sizeof (cairo_text_cluster_t));
    clusterCount = 0;
    utf8Max = len*2; // start with twice the number of glyphs. we will realloc if we need more.
    utf8 = (char *) gmalloc (utf8Max);
    utf8Count = 0;
  }
1173 1174 1175 1176 1177
}

void CairoOutputDev::drawChar(GfxState *state, double x, double y,
			      double dx, double dy,
			      double originX, double originY,
1178
			      CharCode code, int nBytes, Unicode *u, int uLen)
1179
{
1180 1181 1182 1183 1184
  if (currentFont) {
    glyphs[glyphCount].index = currentFont->getGlyph (code, u, uLen);
    glyphs[glyphCount].x = x - originX;
    glyphs[glyphCount].y = y - originY;
    glyphCount++;
1185
    if (use_show_text_glyphs) {
1186 1187
      GooString enc("UTF-8");
      UnicodeMap *utf8Map = globalParams->getUnicodeMap(&enc);
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
      if (utf8Max - utf8Count < uLen*6) {
        // utf8 encoded characters can be up to 6 bytes
	if (utf8Max > uLen*6)
	  utf8Max *= 2;
	else
	  utf8Max += 2*uLen*6;
	utf8 = (char *) grealloc (utf8, utf8Max);
      }
      clusters[clusterCount].num_bytes = 0;
      for (int i = 0; i < uLen; i++) {
1198
	int size = utf8Map->mapUnicode(u[i], utf8 + utf8Count, utf8Max - utf8Count);
1199 1200 1201 1202 1203 1204
	utf8Count += size;
	clusters[clusterCount].num_bytes += size;
      }
      clusters[clusterCount].num_glyphs = 1;
      clusterCount++;
    }
1205 1206 1207
  }

  if (!text)
1208
    return;
1209
  actualText->addChar (state, x, y, dx, dy, code, nBytes, u, uLen);
1210 1211 1212 1213 1214 1215 1216
}

void CairoOutputDev::endString(GfxState *state)
{
  int render;

  if (!currentFont)
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1217
    return;
1218 1219 1220 1221 1222 1223 1224

  // endString can be called without a corresponding beginString. If this
  // happens glyphs will be null so don't draw anything, just return.
  // XXX: OutputDevs should probably not have to deal with this...
  if (!glyphs)
    return;

1225 1226
  // ignore empty strings and invisible text -- this is used by
  // Acrobat Capture
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1227
  render = state->getRender();
1228
  if (render == 3 || glyphCount == 0) {
1229 1230
    gfree(glyphs);
    glyphs = NULL;
1231
    return;
1232
  }
1233

1234
  if (!(render & 1)) {
1235
    LOG (printf ("fill string\n"));
1236
    cairo_set_source (cairo, fill_pattern);
1237
    if (use_show_text_glyphs)
1238 1239 1240
      cairo_show_text_glyphs (cairo, utf8, utf8Count, glyphs, glyphCount, clusters, clusterCount, (cairo_text_cluster_flags_t)0);
    else
        cairo_show_glyphs (cairo, glyphs, glyphCount);
1241 1242
    if (cairo_shape)
      cairo_show_glyphs (cairo_shape, glyphs, glyphCount);
Kristian Høgsberg's avatar
Kristian Høgsberg committed
1243
  }
1244

Kristian Høgsberg's avatar
Kristian Høgsberg committed
1245 1246
  // stroke
  if ((render & 3) == 1 || (render & 3) == 2) {
1247
    LOG (printf ("stroke string\n"));
1248
    cairo_set_source (cairo, stroke_pattern);
1249
    cairo_glyph_path (cairo, glyphs, glyphCount);