Merge lp:~matttbe/ubuntu/quantal/poppler/lp1072129 into lp:ubuntu/quantal-proposed/poppler

[Matthieu Baerts]

Hello,

Due to a bug in poppler, Evince crash when loading some PDF files (LP: #1072129).
This new version simply adds the upstream patch in order to fix this bug.

For more details about this new version, please have a look at this bug #1072129.

Thank you for your help! :)

PS: You can easily test the new version by using these packages:
  - Ubuntu Raring 13.04: https://launchpad.net/~matttbe/+archive/ppa/+sourcepub/2781218/+listing-archive-extra
  - Ubuntu Quantal 12.10: https://launchpad.net/~matttbe/+archive/ppa/+sourcepub/2781220/+listing-archive-extra
PS²: [2012-11-16] ACK still not received by the Ubuntu-SRU team for this new version but I guess this package can already been uploaded to the Quantal queue ;)

[Sebastien Bacher (seb128)]

Thanks for your work Matthieu, I've sponsored that, it's in the queue waiting for review (that can take some weeks before somebody look at it seeing the current backlog from the SRU team there)

review: Approve

[Matthieu Baerts (matttbe)]

Thank you for your help ;)

=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2012-11-16 16:39:27 +0000
@@ -0,0 +1,1 @@
+debian/patches

=== added file '.pc/.quilt_series'
--- .pc/.quilt_series	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_series	2012-11-16 16:39:27 +0000
@@ -0,0 +1,1 @@
+series

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2012-06-07 17:13:58 +0000
+++ .pc/applied-patches	2012-11-16 16:39:27 +0000
@@ -1,1 +1,3 @@
 ltmain-as-needed.diff
+qt4-visibility.diff
+git_gouraud_shading_support.patch

=== added directory '.pc/git_gouraud_shading_support.patch'
=== added directory '.pc/git_gouraud_shading_support.patch/poppler'
=== added file '.pc/git_gouraud_shading_support.patch/poppler/CairoOutputDev.cc'
--- .pc/git_gouraud_shading_support.patch/poppler/CairoOutputDev.cc	1970-01-01 00:00:00 +0000
+++ .pc/git_gouraud_shading_support.patch/poppler/CairoOutputDev.cc	2012-11-16 16:39:27 +0000
@@ -0,0 +1,3121 @@
+//========================================================================
+//
+// CairoOutputDev.cc
+//
+// Copyright 2003 Glyph & Cog, LLC
+// Copyright 2004 Red Hat, Inc
+//
+//========================================================================
+
+//========================================================================
+//
+// Modified under the Poppler project - http://poppler.freedesktop.org
+//
+// All changes made under the Poppler project to this file are licensed
+// under GPL version 2 or later
+//
+// Copyright (C) 2005-2008 Jeff Muizelaar <[e-mail]>
+// Copyright (C) 2005, 2006 Kristian Høgsberg <[e-mail]>
+// Copyright (C) 2005, 2009, 2012 Albert Astals Cid <[e-mail]>
+// Copyright (C) 2005 Nickolay V. Shmyrev <[e-mail]>
+// Copyright (C) 2006-2011 Carlos Garcia Campos <[e-mail]>
+// Copyright (C) 2008 Carl Worth <[e-mail]>
+// Copyright (C) 2008-2012 Adrian Johnson <[e-mail]>
+// Copyright (C) 2008 Michael Vrable <[e-mail]>
+// Copyright (C) 2008, 2009 Chris Wilson <[e-mail]>
+// Copyright (C) 2008 Hib Eris <[e-mail]>
+// Copyright (C) 2009, 2010 David Benjamin <[e-mail]>
+// Copyright (C) 2011, 2012 Thomas Freitag <[e-mail]>
+// Copyright (C) 2012 Patrick Pfeifer <[e-mail]>
+//
+// 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
+//
+//========================================================================
+
+#include <config.h>
+
+#ifdef USE_GCC_PRAGMAS
+#pragma implementation
+#endif
+
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include <cairo.h>
+
+#include "goo/gfile.h"
+#include "goo/gtypes_p.h"
+#include "GlobalParams.h"
+#include "Error.h"
+#include "Object.h"
+#include "Gfx.h"
+#include "GfxState.h"
+#include "GfxFont.h"
+#include "Page.h"
+#include "Link.h"
+#include "FontEncodingTables.h"
+#include "PDFDocEncoding.h"
+#include <fofi/FoFiTrueType.h>
+#include <splash/SplashBitmap.h>
+#include "CairoOutputDev.h"
+#include "CairoFontEngine.h"
+#include "CairoRescaleBox.h"
+#include "UTF8.h"
+//------------------------------------------------------------------------
+
+// #define LOG_CAIRO
+
+#ifdef LOG_CAIRO
+#define LOG(x) (x)
+#else
+#define LOG(x)
+#endif
+
+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);
+}
+
+
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+
+
+//------------------------------------------------------------------------
+// CairoImage
+//------------------------------------------------------------------------
+
+CairoImage::CairoImage (double x1, double y1, double x2, double y2) {
+  this->image = NULL;
+  this->x1 = x1;
+  this->y1 = y1;
+  this->x2 = x2;
+  this->y2 = y2;
+}
+
+CairoImage::~CairoImage () {
+  if (image)
+    cairo_surface_destroy (image);
+}
+
+void CairoImage::setImage (cairo_surface_t *image) {
+  if (this->image)
+    cairo_surface_destroy (this->image);
+  this->image = cairo_surface_reference (image);
+}
+
+//------------------------------------------------------------------------
+// CairoOutputDev
+//------------------------------------------------------------------------
+
+// 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;
+
+CairoOutputDev::CairoOutputDev() {
+  doc = NULL;
+
+  if (!ft_lib_initialized) {
+    FT_Init_FreeType(&ft_lib);
+    ft_lib_initialized = gTrue;
+  }
+
+  fontEngine = NULL;
+  fontEngine_owner = gFalse;
+  glyphs = NULL;
+  fill_pattern = NULL;
+  fill_color.r = fill_color.g = fill_color.b = 0;
+  stroke_pattern = NULL;
+  stroke_color.r = stroke_color.g = stroke_color.b = 0;
+  stroke_opacity = 1.0;
+  fill_opacity = 1.0;
+  textClipPath = NULL;
+  strokePathClip = NULL;
+  cairo = NULL;
+  currentFont = NULL;
+  prescaleImages = gTrue;
+  printing = gTrue;
+  use_show_text_glyphs = gFalse;
+  inType3Char = gFalse;
+  t3_glyph_has_bbox = gFalse;
+
+  groupColorSpaceStack = NULL;
+  maskStack = NULL;
+  group = NULL;
+  mask = NULL;
+  shape = NULL;
+  cairo_shape = NULL;
+  knockoutCount = 0;
+
+  text = NULL;
+  actualText = NULL;
+
+  // the SA parameter supposedly defaults to false, but Acrobat
+  // apparently hardwires it to true
+  stroke_adjust = globalParams->getStrokeAdjust();
+  align_stroke_coords = gFalse;
+  adjusted_stroke_width = gFalse;
+}
+
+CairoOutputDev::~CairoOutputDev() {
+  if (fontEngine_owner && fontEngine) {
+    delete fontEngine;
+  }
+
+  if (cairo)
+    cairo_destroy (cairo);
+  cairo_pattern_destroy (stroke_pattern);
+  cairo_pattern_destroy (fill_pattern);
+  if (group)
+    cairo_pattern_destroy (group);
+  if (mask)
+    cairo_pattern_destroy (mask);
+  if (shape)
+    cairo_pattern_destroy (shape);
+  if (text) 
+    text->decRefCnt();
+  if (actualText)
+    delete actualText;  
+}
+
+void CairoOutputDev::setCairo(cairo_t *cairo)
+{
+  if (this->cairo != NULL) {
+    cairo_status_t status = cairo_status (this->cairo);
+    if (status) {
+      error(errInternal, -1, "cairo context error: {0:s}\n", cairo_status_to_string(status));
+    }
+    cairo_destroy (this->cairo);
+    assert(!cairo_shape);
+  }
+  if (cairo != NULL) {
+    this->cairo = cairo_reference (cairo);
+	/* 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 {
+    this->cairo = NULL;
+    this->cairo_shape = NULL;
+  }
+}
+
+void CairoOutputDev::setTextPage(TextPage *text)
+{
+  if (this->text) 
+    this->text->decRefCnt();
+  if (actualText)
+    delete actualText;
+  if (text) {
+    this->text = text;
+    this->text->incRefCnt();
+    actualText = new ActualText(text);
+  } else {
+    this->text = NULL;
+    actualText = NULL;
+  }
+}
+
+void CairoOutputDev::startDoc(PDFDoc *docA,
+			      CairoFontEngine *parentFontEngine) {
+  doc = docA;
+  if (parentFontEngine) {
+    fontEngine = parentFontEngine;
+  } else {
+    if (fontEngine) {
+      delete fontEngine;
+    }
+    fontEngine = new CairoFontEngine(ft_lib);
+    fontEngine_owner = gTrue;
+  }
+}
+
+void CairoOutputDev::startPage(int pageNum, GfxState *state) {
+  /* set up some per page defaults */
+  cairo_pattern_destroy(fill_pattern);
+  cairo_pattern_destroy(stroke_pattern);
+
+  fill_pattern = cairo_pattern_create_rgb(0., 0., 0.);
+  stroke_pattern = cairo_pattern_reference(fill_pattern);
+
+  if (text)
+    text->startPage(state);
+}
+
+void CairoOutputDev::endPage() {
+  if (text) {
+    text->endPage();
+    text->coalesce(gTrue, 0, gFalse);
+  }
+}
+
+void CairoOutputDev::saveState(GfxState *state) {
+  LOG(printf ("save\n"));
+  cairo_save (cairo);
+  if (cairo_shape)
+      cairo_save (cairo_shape);
+
+  MaskStack *ms = new MaskStack;
+  ms->mask = cairo_pattern_reference(mask);
+  ms->mask_matrix = mask_matrix;
+  ms->next = maskStack;
+  maskStack = ms;
+}
+
+void CairoOutputDev::restoreState(GfxState *state) {
+  LOG(printf ("restore\n"));
+  cairo_restore (cairo);
+  if (cairo_shape)
+      cairo_restore (cairo_shape);
+
+  /* These aren't restored by cairo_restore() since we keep them in
+   * the output device. */
+  updateFillColor(state);
+  updateStrokeColor(state);
+  updateFillOpacity(state);
+  updateStrokeOpacity(state);
+  updateBlendMode(state);
+
+  MaskStack* ms = maskStack;
+  if (ms) {
+    if (mask)
+      cairo_pattern_destroy(mask);
+    mask = ms->mask;
+    mask_matrix = ms->mask_matrix;
+    maskStack = ms->next;
+    delete ms;
+  }
+}
+
+void CairoOutputDev::updateAll(GfxState *state) {
+  updateLineDash(state);
+  updateLineJoin(state);
+  updateLineCap(state);
+  updateLineWidth(state);
+  updateFlatness(state);
+  updateMiterLimit(state);
+  updateFillColor(state);
+  updateStrokeColor(state);
+  updateFillOpacity(state);
+  updateStrokeOpacity(state);
+  updateBlendMode(state);
+  needFontUpdate = gTrue;
+  if (text)
+    text->updateFont(state);
+}
+
+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];
+
+  cairo_transform (cairo, &matrix);
+  if (cairo_shape)
+      cairo_transform (cairo_shape, &matrix);
+
+  OutputDev::setDefaultCTM(ctm);
+}
+
+void CairoOutputDev::updateCTM(GfxState *state, double m11, double m12,
+				double m21, double m22,
+				double m31, double m32) {
+  cairo_matrix_t matrix, invert_matrix;
+  matrix.xx = m11;
+  matrix.yx = m12;
+  matrix.xy = m21;
+  matrix.yy = m22;
+  matrix.x0 = m31;
+  matrix.y0 = m32;
+
+  /* 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
+   * instead of having to invert the matrix. */
+  invert_matrix = matrix;
+  if (cairo_matrix_invert(&invert_matrix)) {
+    error(errSyntaxWarning, -1, "matrix not invertible\n");
+    return;
+  }
+
+  cairo_transform (cairo, &matrix);
+  if (cairo_shape)
+    cairo_transform (cairo_shape, &matrix);
+  updateLineDash(state);
+  updateLineJoin(state);
+  updateLineCap(state);
+  updateLineWidth(state);
+}
+
+void CairoOutputDev::updateLineDash(GfxState *state) {
+  double *dashPattern;
+  int dashLength;
+  double dashStart;
+
+  state->getLineDash(&dashPattern, &dashLength, &dashStart);
+  cairo_set_dash (cairo, dashPattern, dashLength, dashStart);
+  if (cairo_shape)
+    cairo_set_dash (cairo_shape, dashPattern, dashLength, dashStart);
+}
+
+void CairoOutputDev::updateFlatness(GfxState *state) {
+  // cairo_set_tolerance (cairo, state->getFlatness());
+}
+
+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;
+  }
+  if (cairo_shape)
+    cairo_set_line_join (cairo_shape, cairo_get_line_join(cairo));
+}
+
+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;
+  }
+  if (cairo_shape)
+    cairo_set_line_cap (cairo_shape, cairo_get_line_cap(cairo));
+}
+
+void CairoOutputDev::updateMiterLimit(GfxState *state) {
+  cairo_set_miter_limit (cairo, state->getMiterLimit());
+  if (cairo_shape)
+    cairo_set_miter_limit (cairo_shape, state->getMiterLimit());
+}
+
+void CairoOutputDev::updateLineWidth(GfxState *state) {
+  LOG(printf ("line width: %f\n", state->getLineWidth()));
+  adjusted_stroke_width = gFalse;
+  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.
+     */
+    double x = 1.0, y = 1.0;
+    if (printing) {
+      // assume printer pixel size is 1/600 inch
+      x = 72.0/600;
+      y = 72.0/600;
+    }
+    cairo_device_to_user_distance(cairo, &x, &y);
+    width = MIN(fabs(x),fabs(y));
+  }
+  cairo_set_line_width (cairo, width);
+  if (cairo_shape)
+    cairo_set_line_width (cairo_shape, cairo_get_line_width (cairo));
+}
+
+void CairoOutputDev::updateFillColor(GfxState *state) {
+  GfxRGB color = fill_color;
+
+  state->getFillRGB(&fill_color);
+  if (cairo_pattern_get_type (fill_pattern) != CAIRO_PATTERN_TYPE_SOLID ||
+      color.r != fill_color.r ||
+      color.g != fill_color.g ||
+      color.b != fill_color.b)
+  {
+    cairo_pattern_destroy(fill_pattern);
+    fill_pattern = cairo_pattern_create_rgba(colToDbl(fill_color.r),
+					     colToDbl(fill_color.g),
+					     colToDbl(fill_color.b),
+					     fill_opacity);
+
+    LOG(printf ("fill color: %d %d %d\n",
+		fill_color.r, fill_color.g, fill_color.b));
+  }
+}
+
+void CairoOutputDev::updateStrokeColor(GfxState *state) {
+  GfxRGB color = stroke_color;
+
+  state->getStrokeRGB(&stroke_color);
+  if (cairo_pattern_get_type (fill_pattern) != CAIRO_PATTERN_TYPE_SOLID ||
+      color.r != stroke_color.r ||
+      color.g != stroke_color.g ||
+      color.b != stroke_color.b)
+  {
+    cairo_pattern_destroy(stroke_pattern);
+    stroke_pattern = cairo_pattern_create_rgba(colToDbl(stroke_color.r),
+					       colToDbl(stroke_color.g),
+					       colToDbl(stroke_color.b),
+					       stroke_opacity);
+
+    LOG(printf ("stroke color: %d %d %d\n",
+		stroke_color.r, stroke_color.g, stroke_color.b));
+  }
+}
+
+void CairoOutputDev::updateFillOpacity(GfxState *state) {
+  double opacity = fill_opacity;
+
+  fill_opacity = state->getFillOpacity();
+  if (opacity != fill_opacity) {
+    cairo_pattern_destroy(fill_pattern);
+    fill_pattern = cairo_pattern_create_rgba(colToDbl(fill_color.r),
+					     colToDbl(fill_color.g),
+					     colToDbl(fill_color.b),
+					     fill_opacity);
+
+    LOG(printf ("fill opacity: %f\n", fill_opacity));
+  }
+}
+
+void CairoOutputDev::updateStrokeOpacity(GfxState *state) {
+  double opacity = stroke_opacity;
+
+  stroke_opacity = state->getStrokeOpacity();
+  if (opacity != stroke_opacity) {
+    cairo_pattern_destroy(stroke_pattern);
+    stroke_pattern = cairo_pattern_create_rgba(colToDbl(stroke_color.r),
+					       colToDbl(stroke_color.g),
+					       colToDbl(stroke_color.b),
+					       stroke_opacity);
+
+    LOG(printf ("stroke opacity: %f\n", stroke_opacity));
+  }
+}
+
+void CairoOutputDev::updateFillColorStop(GfxState *state, double offset) {
+  state->getFillRGB(&fill_color);
+
+  cairo_pattern_add_color_stop_rgba(fill_pattern, offset,
+				    colToDbl(fill_color.r),
+				    colToDbl(fill_color.g),
+				    colToDbl(fill_color.b),
+				    fill_opacity);
+  LOG(printf ("fill color stop: %f (%d, %d, %d)\n",
+	      offset, fill_color.r, fill_color.g, fill_color.b));
+}
+
+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()));
+}
+
+void CairoOutputDev::updateFont(GfxState *state) {
+  cairo_font_face_t *font_face;
+  cairo_matrix_t matrix, invert_matrix;
+
+  LOG(printf ("updateFont() font=%s\n", state->getFont()->getName()->getCString()));
+
+  needFontUpdate = gFalse;
+
+  //FIXME: use cairo font engine?
+  if (text)
+    text->updateFont(state);
+  
+  currentFont = fontEngine->getFont (state->getFont(), doc, printing);
+
+  if (!currentFont)
+    return;
+
+  font_face = currentFont->getFontFace();
+  cairo_set_font_face (cairo, font_face);
+
+  use_show_text_glyphs = state->getFont()->hasToUnicodeCMap() &&
+    cairo_surface_has_show_text_glyphs (cairo_get_target (cairo));
+ 
+  double fontSize = state->getFontSize();
+  double *m = state->getTextMat();
+  /* 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;
+  matrix.xy = -m[2] * fontSize;
+  matrix.yy = -m[3] * fontSize;
+  matrix.x0 = 0;
+  matrix.y0 = 0;
+
+  LOG(printf ("font matrix: %f %f %f %f\n", matrix.xx, matrix.yx, matrix.xy, matrix.yy));
+
+ /* 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)) {
+    error(errSyntaxWarning, -1, "font matrix not invertible\n");
+    return;
+  }
+
+  cairo_set_font_matrix (cairo, &matrix);
+}
+
+/* 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)
+{
+  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);
+  }
+}
+
+#undef STROKE_COORD_TOLERANCE
+
+void CairoOutputDev::doPath(cairo_t *cairo, GfxState *state, GfxPath *path) {
+  GfxSubpath *subpath;
+  int i, j;
+  double x, y;
+  cairo_new_path (cairo);
+  for (i = 0; i < path->getNumSubpaths(); ++i) {
+    subpath = path->getSubpath(i);
+    if (subpath->getNumPoints() > 0) {
+      if (align_stroke_coords) {
+        alignStrokeCoords(subpath, 0, &x, &y);
+      } else {
+        x = subpath->getX(0);
+        y = subpath->getY(0);
+      }
+      cairo_move_to (cairo, x, y);
+      j = 1;
+      while (j < subpath->getNumPoints()) {
+	if (subpath->getCurve(j)) {
+	  if (align_stroke_coords) {
+            alignStrokeCoords(subpath, j + 2, &x, &y);
+          } else {
+            x = subpath->getX(j+2);
+            y = subpath->getY(j+2);
+          }
+	  cairo_curve_to( cairo,
+			  subpath->getX(j), subpath->getY(j),
+			  subpath->getX(j+1), subpath->getY(j+1),
+			  x, y);
+
+	  j += 3;
+	} else {
+	  if (align_stroke_coords) {
+            alignStrokeCoords(subpath, j, &x, &y);
+          } else {
+            x = subpath->getX(j);
+            y = subpath->getY(j);
+          }
+          cairo_line_to (cairo, x, y);
+	  ++j;
+	}
+      }
+      if (subpath->isClosed()) {
+	LOG (printf ("close\n"));
+	cairo_close_path (cairo);
+      }
+    }
+  }
+}
+
+void CairoOutputDev::stroke(GfxState *state) {
+  if (inType3Char) {
+      GfxGray gray;
+      state->getFillGray(&gray);
+      if (colToDbl(gray) > 0.5)
+	  return;
+  }
+
+  if (adjusted_stroke_width)
+    align_stroke_coords = gTrue;
+  doPath (cairo, state, state->getPath());
+  align_stroke_coords = gFalse;
+  cairo_set_source (cairo, stroke_pattern);
+  LOG(printf ("stroke\n"));
+  cairo_stroke (cairo);
+  if (cairo_shape) {
+    doPath (cairo_shape, state, state->getPath());
+    cairo_stroke (cairo_shape);
+  }
+}
+
+void CairoOutputDev::fill(GfxState *state) {
+  if (inType3Char) {
+      GfxGray gray;
+      state->getFillGray(&gray);
+      if (colToDbl(gray) > 0.5)
+	  return;
+  }
+
+  doPath (cairo, state, state->getPath());
+  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_WINDING);
+  cairo_set_source (cairo, fill_pattern);
+  LOG(printf ("fill\n"));
+  //XXX: how do we get the path
+  if (mask) {
+    cairo_save (cairo);
+    cairo_clip (cairo);
+    cairo_set_matrix (cairo, &mask_matrix);
+    cairo_mask (cairo, mask);
+    cairo_restore (cairo);
+  } else if (strokePathClip) {
+    fillToStrokePathClip(state);
+  } else {
+    cairo_fill (cairo);
+  }
+  if (cairo_shape) {
+    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_WINDING);
+    doPath (cairo_shape, state, state->getPath());
+    cairo_fill (cairo_shape);
+  }
+}
+
+void CairoOutputDev::eoFill(GfxState *state) {
+  doPath (cairo, state, state->getPath());
+  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_EVEN_ODD);
+  cairo_set_source (cairo, fill_pattern);
+  LOG(printf ("fill-eo\n"));
+  cairo_fill (cairo);
+
+  if (cairo_shape) {
+    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_EVEN_ODD);
+    doPath (cairo_shape, state, state->getPath());
+    cairo_fill (cairo_shape);
+  }
+
+}
+
+GBool CairoOutputDev::tilingPatternFill(GfxState *state, Gfx *gfx1, Catalog *cat, Object *str,
+					double *pmat, int paintType, int /*tilingType*/, Dict *resDict,
+					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;
+  double width, height;
+  int surface_width, surface_height;
+  StrokePathClip *strokePathTmp;
+
+  width = bbox[2] - bbox[0];
+  height = bbox[3] - bbox[1];
+
+  if (xStep != width || yStep != height)
+    return gFalse;
+  /* TODO: implement the other cases here too */
+
+  surface_width = (int) ceil (width);
+  surface_height = (int) ceil (height);
+
+  surface = cairo_surface_create_similar (cairo_get_target (cairo),
+					  CAIRO_CONTENT_COLOR_ALPHA,
+					  surface_width, surface_height);
+  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];
+  strokePathTmp = strokePathClip;
+  strokePathClip = NULL;
+  gfx = new Gfx(doc, this, resDict, &box, NULL);
+  gfx->display(str);
+  delete gfx;
+  strokePathClip = strokePathTmp;
+
+  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);
+
+  cairo_matrix_init_scale (&matrix, surface_width / width, surface_height / height);
+  cairo_pattern_set_matrix (pattern, &matrix);
+
+  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);
+  if (strokePathClip) {
+    fillToStrokePathClip(state);
+  } else {
+    cairo_fill (cairo);
+  }
+
+  cairo_pattern_destroy (pattern);
+
+  return gTrue;
+}
+
+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);
+  if (!shading->getExtend0() && !shading->getExtend1())
+    cairo_pattern_set_extend (fill_pattern, CAIRO_EXTEND_NONE);
+  else
+    cairo_pattern_set_extend (fill_pattern, CAIRO_EXTEND_PAD);
+
+  LOG (printf ("axial-sh\n"));
+
+  // TODO: use the actual stops in the shading in the case
+  // of linear interpolation (Type 2 Exponential functions with N=1)
+  return gFalse;
+}
+
+GBool CairoOutputDev::axialShadedSupportExtend(GfxState *state, GfxAxialShading *shading)
+{
+  return (shading->getExtend0() == shading->getExtend1());
+}
+
+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);
+
+  LOG (printf ("radial-sh\n"));
+
+  return gFalse;
+}
+
+GBool CairoOutputDev::radialShadedSupportExtend(GfxState *state, GfxRadialShading *shading)
+{
+  return (shading->getExtend0() == shading->getExtend1());
+}
+
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0)
+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++) {
+    shading->getTriangle(i,
+			 &x0, &y0, &color[0],
+			 &x1, &y1, &color[1],
+			 &x2, &y2, &color[2]);
+
+    cairo_mesh_pattern_begin_patch (fill_pattern);
+
+    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);
+
+    for (j = 0; j < 3; j++) {
+	shading->getColorSpace()->getRGB(&color[j], &rgb);
+	cairo_mesh_pattern_set_corner_color_rgb (fill_pattern, j,
+						 colToDbl(rgb.r),
+						 colToDbl(rgb.g),
+						 colToDbl(rgb.b));
+    }
+
+    cairo_mesh_pattern_end_patch (fill_pattern);
+  }
+
+  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;
+
+    cairo_mesh_pattern_begin_patch (fill_pattern);
+
+    cairo_mesh_pattern_move_to (fill_pattern, patch->x[0][0], patch->y[0][0]);
+    cairo_mesh_pattern_curve_to (fill_pattern,
+			    patch->x[0][1], patch->y[0][1],
+			    patch->x[0][2], patch->y[0][2],
+			    patch->x[0][3], patch->y[0][3]);
+
+    cairo_mesh_pattern_curve_to (fill_pattern,
+			    patch->x[1][3], patch->y[1][3],
+			    patch->x[2][3], patch->y[2][3],
+			    patch->x[3][3], patch->y[3][3]);
+
+    cairo_mesh_pattern_curve_to (fill_pattern,
+			    patch->x[3][2], patch->y[3][2],
+			    patch->x[3][1], patch->y[3][1],
+			    patch->x[3][0], patch->y[3][0]);
+
+    cairo_mesh_pattern_curve_to (fill_pattern,
+			    patch->x[2][0], patch->y[2][0],
+			    patch->x[1][0], patch->y[1][0],
+			    patch->x[0][0], patch->y[0][0]);
+
+    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]);
+
+    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);
+      cairo_mesh_pattern_set_corner_color_rgb (fill_pattern, j,
+					       colToDbl(rgb.r),
+					       colToDbl(rgb.g),
+					       colToDbl(rgb.b));
+    }
+    cairo_mesh_pattern_end_patch (fill_pattern);
+  }
+
+  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;
+}
+#endif /* CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 12, 0) */
+
+void CairoOutputDev::clip(GfxState *state) {
+  doPath (cairo, state, state->getPath());
+  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_WINDING);
+  cairo_clip (cairo);
+  LOG (printf ("clip\n"));
+  if (cairo_shape) {
+    doPath (cairo_shape, state, state->getPath());
+    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_WINDING);
+    cairo_clip (cairo_shape);
+  }
+}
+
+void CairoOutputDev::eoClip(GfxState *state) {
+  doPath (cairo, state, state->getPath());
+  cairo_set_fill_rule (cairo, CAIRO_FILL_RULE_EVEN_ODD);
+  cairo_clip (cairo);
+  LOG (printf ("clip-eo\n"));
+  if (cairo_shape) {
+    doPath (cairo_shape, state, state->getPath());
+    cairo_set_fill_rule (cairo_shape, CAIRO_FILL_RULE_EVEN_ODD);
+    cairo_clip (cairo_shape);
+  }
+
+}
+
+void CairoOutputDev::clipToStrokePath(GfxState *state) {
+  LOG(printf("clip-to-stroke-path\n"));
+  strokePathClip = (StrokePathClip*)gmalloc (sizeof(*strokePathClip));
+  strokePathClip->path = state->getPath()->copy();
+  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);
+}
+
+void CairoOutputDev::fillToStrokePathClip(GfxState *state) {
+  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);
+  doPath (cairo, state, strokePathClip->path);
+  cairo_stroke (cairo);
+
+  cairo_restore (cairo);
+
+  delete strokePathClip->path;
+  if (strokePathClip->dashes)
+    gfree (strokePathClip->dashes);
+  gfree (strokePathClip);
+  strokePathClip = NULL;
+}
+
+void CairoOutputDev::beginString(GfxState *state, GooString *s)
+{
+  int len = s->getLength();
+
+  if (needFontUpdate)
+    updateFont(state);
+
+  if (!currentFont)
+    return;
+
+  glyphs = (cairo_glyph_t *) gmallocn (len, sizeof (cairo_glyph_t));
+  glyphCount = 0;
+  if (use_show_text_glyphs) {
+    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;
+  }
+}
+
+void CairoOutputDev::drawChar(GfxState *state, double x, double y,
+			      double dx, double dy,
+			      double originX, double originY,
+			      CharCode code, int nBytes, Unicode *u, int uLen)
+{
+  if (currentFont) {
+    glyphs[glyphCount].index = currentFont->getGlyph (code, u, uLen);
+    glyphs[glyphCount].x = x - originX;
+    glyphs[glyphCount].y = y - originY;
+    glyphCount++;
+    if (use_show_text_glyphs) {
+      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++) {
+	int size = mapUTF8 (u[i], utf8 + utf8Count, utf8Max - utf8Count);
+	utf8Count += size;
+	clusters[clusterCount].num_bytes += size;
+      }
+      clusters[clusterCount].num_glyphs = 1;
+      clusterCount++;
+    }
+  }
+
+  if (!text)
+    return;
+  actualText->addChar (state, x, y, dx, dy, code, nBytes, u, uLen);
+}
+
+void CairoOutputDev::endString(GfxState *state)
+{
+  int render;
+
+  if (!currentFont)
+    return;
+
+  // 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;
+
+  // ignore empty strings and invisible text -- this is used by
+  // Acrobat Capture
+  render = state->getRender();
+  if (render == 3 || glyphCount == 0) {
+    gfree(glyphs);
+    glyphs = NULL;
+    return;
+  }
+
+  if (!(render & 1)) {
+    LOG (printf ("fill string\n"));
+    cairo_set_source (cairo, fill_pattern);
+    if (use_show_text_glyphs)
+      cairo_show_text_glyphs (cairo, utf8, utf8Count, glyphs, glyphCount, clusters, clusterCount, (cairo_text_cluster_flags_t)0);
+    else
+        cairo_show_glyphs (cairo, glyphs, glyphCount);
+    if (cairo_shape)
+      cairo_show_glyphs (cairo_shape, glyphs, glyphCount);
+  }
+
+  // stroke
+  if ((render & 3) == 1 || (render & 3) == 2) {
+    LOG (printf ("stroke string\n"));
+    cairo_set_source (cairo, stroke_pattern);
+    cairo_glyph_path (cairo, glyphs, glyphCount);
+    cairo_stroke (cairo);
+    if (cairo_shape) {
+      cairo_glyph_path (cairo_shape, glyphs, glyphCount);
+      cairo_stroke (cairo_shape);
+    }
+  }
+
+  // clip
+  if ((render & 4)) {
+    LOG (printf ("clip string\n"));
+    // append the glyph path to textClipPath.
+
+    // set textClipPath as the currentPath
+    if (textClipPath) {
+      cairo_append_path (cairo, textClipPath);
+      if (cairo_shape) {
+	cairo_append_path (cairo_shape, textClipPath);
+      }
+      cairo_path_destroy (textClipPath);
+    }
+    
+    // append the glyph path
+    cairo_glyph_path (cairo, glyphs, glyphCount);
+   
+    // move the path back into textClipPath 
+    // and clear the current path
+    textClipPath = cairo_copy_path (cairo);
+    cairo_new_path (cairo);
+    if (cairo_shape) {
+      cairo_new_path (cairo_shape);
+    }
+  }
+
+  gfree (glyphs);
+  glyphs = NULL;
+  if (use_show_text_glyphs) {
+    gfree (clusters);
+    clusters = NULL;
+    gfree (utf8);
+    utf8 = NULL;
+  }
+}
+
+
+GBool CairoOutputDev::beginType3Char(GfxState *state, double x, double y,
+				      double dx, double dy,
+				      CharCode code, Unicode *u, int uLen) {
+
+  cairo_save (cairo);
+  double *ctm;
+  cairo_matrix_t matrix;
+
+  ctm = state->getCTM();
+  matrix.xx = ctm[0];
+  matrix.yx = ctm[1];
+  matrix.xy = ctm[2];
+  matrix.yy = ctm[3];
+  matrix.x0 = ctm[4];
+  matrix.y0 = ctm[5];
+  /* Restore the original matrix and then transform to matrix needed for the
+   * type3 font. This is ugly but seems to work. Perhaps there is a better way to do it?*/
+  cairo_set_matrix(cairo, &orig_matrix);
+  cairo_transform(cairo, &matrix);
+  if (cairo_shape) {
+    cairo_save (cairo_shape);
+    cairo_set_matrix(cairo_shape, &orig_matrix);
+    cairo_transform(cairo_shape, &matrix);
+  }
+  cairo_pattern_destroy(stroke_pattern);
+  cairo_pattern_reference(fill_pattern);
+  stroke_pattern = fill_pattern;
+  return gFalse;
+}
+
+void CairoOutputDev::endType3Char(GfxState *state) {
+  cairo_restore (cairo);
+  if (cairo_shape) {
+    cairo_restore (cairo_shape);
+  }
+}
+
+void CairoOutputDev::type3D0(GfxState *state, double wx, double wy) {
+  t3_glyph_wx = wx;
+  t3_glyph_wy = wy;
+}
+
+void CairoOutputDev::type3D1(GfxState *state, double wx, double wy,
+			     double llx, double lly, double urx, double ury) {
+  t3_glyph_wx = wx;
+  t3_glyph_wy = wy;
+  t3_glyph_bbox[0] = llx;
+  t3_glyph_bbox[1] = lly;
+  t3_glyph_bbox[2] = urx;
+  t3_glyph_bbox[3] = ury;
+  t3_glyph_has_bbox = gTrue;
+}
+
+void CairoOutputDev::beginTextObject(GfxState *state) {
+}
+
+void CairoOutputDev::endTextObject(GfxState *state) {
+  if (textClipPath) {
+    // clip the accumulated text path
+    cairo_append_path (cairo, textClipPath);
+    cairo_clip (cairo);
+    if (cairo_shape) {
+      cairo_append_path (cairo_shape, textClipPath);
+      cairo_clip (cairo_shape);
+    }
+    cairo_path_destroy (textClipPath);
+    textClipPath = NULL;
+  }
+}
+
+void CairoOutputDev::beginActualText(GfxState *state, GooString *text)
+{
+  if (this->text)
+    actualText->begin(state, text);
+}
+
+void CairoOutputDev::endActualText(GfxState *state)
+{
+  if (text)
+    actualText->end(state);
+}
+
+static inline int splashRound(SplashCoord x) {
+  return (int)floor(x + 0.5);
+}
+
+static inline int splashCeil(SplashCoord x) {
+  return (int)ceil(x);
+}
+
+static inline int splashFloor(SplashCoord x) {
+  return (int)floor(x);
+}
+
+static
+cairo_surface_t *cairo_surface_create_similar_clip (cairo_t *cairo, cairo_content_t content)
+{
+  double x1, y1, x2, y2;
+  int width, height;
+  cairo_clip_extents (cairo, &x1, &y1, &x2, &y2);
+  cairo_matrix_t matrix;
+  cairo_get_matrix (cairo, &matrix);
+  //cairo_matrix_transform_point(&matrix, &x1, &y1);
+  //cairo_matrix_transform_point(&matrix, &x2, &y2);*/
+  cairo_user_to_device(cairo, &x1, &y1);
+  cairo_user_to_device(cairo, &x2, &y2);
+  width = splashCeil(x2) - splashFloor(x1);
+  //XXX: negative matrix
+  ////height = splashCeil(y2) - splashFloor(y1);
+  height = splashFloor(y1) - splashCeil(y2);
+  cairo_surface_t *target = cairo_get_target (cairo);
+  cairo_surface_t *result;
+
+  result = cairo_surface_create_similar (target, content, width, height);
+  double x_offset, y_offset;
+    cairo_surface_get_device_offset(target, &x_offset, &y_offset);
+    cairo_surface_set_device_offset(result, x_offset, y_offset);
+
+ 
+  return result;
+}
+
+
+
+void CairoOutputDev::beginTransparencyGroup(GfxState * /*state*/, double * /*bbox*/,
+                                      GfxColorSpace * blendingColorSpace,
+                                      GBool /*isolated*/, GBool knockout,
+				      GBool forSoftMask) {
+  /* push color space */
+  ColorSpaceStack* css = new ColorSpaceStack;
+  css->cs = blendingColorSpace;
+  css->knockout = knockout;
+  cairo_get_matrix(cairo, &css->group_matrix);
+  css->next = groupColorSpaceStack;
+  groupColorSpaceStack = css;
+
+  LOG(printf ("begin transparency group. knockout: %s\n", knockout ? "yes":"no"));
+
+  if (knockout) {
+    knockoutCount++;
+    if (!cairo_shape) {
+      /* create a surface for tracking the shape */
+      cairo_surface_t *cairo_shape_surface = cairo_surface_create_similar_clip (cairo, CAIRO_CONTENT_ALPHA);
+      cairo_shape = cairo_create (cairo_shape_surface);
+      cairo_surface_destroy (cairo_shape_surface);
+
+      /* the color doesn't matter as long as it is opaque */
+      cairo_set_source_rgb (cairo_shape, 0, 0, 0);
+      cairo_matrix_t matrix;
+      cairo_get_matrix (cairo, &matrix);
+      //printMatrix(&matrix);
+      cairo_set_matrix (cairo_shape, &matrix);
+    } else {
+      cairo_reference (cairo_shape);
+    }
+  }
+  if (groupColorSpaceStack->next && groupColorSpaceStack->next->knockout) {
+    /* we need to track the shape */
+    cairo_push_group (cairo_shape);
+  }
+  if (0 && forSoftMask)
+    cairo_push_group_with_content (cairo, CAIRO_CONTENT_ALPHA);
+  else
+    cairo_push_group (cairo);
+
+  /* push_group has an implicit cairo_save() */
+  if (knockout) {
+    /*XXX: let's hope this matches the semantics needed */
+    cairo_set_operator(cairo, CAIRO_OPERATOR_SOURCE);
+  } else {
+    cairo_set_operator(cairo, CAIRO_OPERATOR_OVER);
+  }
+}
+
+void CairoOutputDev::endTransparencyGroup(GfxState * /*state*/) {
+  if (group)
+    cairo_pattern_destroy(group);
+  group = cairo_pop_group (cairo);
+
+  LOG(printf ("end transparency group\n"));
+
+  if (groupColorSpaceStack->next && groupColorSpaceStack->next->knockout) {
+    if (shape)
+      cairo_pattern_destroy(shape);
+    shape = cairo_pop_group (cairo_shape);
+  }
+}
+
+void CairoOutputDev::paintTransparencyGroup(GfxState * /*state*/, double * /*bbox*/) {
+  LOG(printf ("paint transparency group\n"));
+
+  cairo_save (cairo);
+  cairo_set_matrix (cairo, &groupColorSpaceStack->group_matrix);
+  cairo_set_source (cairo, group);
+
+  if (!mask) {
+    //XXX: deal with mask && shape case
+    if (shape) {
+      cairo_save (cairo);
+
+      /* OPERATOR_SOURCE w/ a mask is defined as (src IN mask) ADD (dest OUT mask)
+       * however our source has already been clipped to mask so we only need to
+       * do ADD and OUT */
+
+      /* clear the shape mask */
+      cairo_set_source (cairo, shape);
+      cairo_set_operator (cairo, CAIRO_OPERATOR_DEST_OUT);
+      cairo_paint (cairo);
+
+      cairo_set_operator (cairo, CAIRO_OPERATOR_ADD);
+      cairo_set_source (cairo, group);
+      cairo_paint (cairo);
+
+      cairo_restore (cairo);
+
+      cairo_pattern_destroy (shape);
+      shape = NULL;
+    } else {
+      cairo_paint_with_alpha (cairo, fill_opacity);
+    }
+    cairo_status_t status = cairo_status(cairo);
+    if (status)
+      printf("BAD status: %s\n", cairo_status_to_string(status));
+  } else {
+    if (fill_opacity < 1.0) {
+      cairo_push_group(cairo);
+    }
+    cairo_save(cairo);
+    cairo_set_matrix(cairo, &mask_matrix);
+    cairo_mask(cairo, mask);
+    cairo_restore(cairo);
+    if (fill_opacity < 1.0) {
+      cairo_pop_group_to_source(cairo);
+      cairo_paint_with_alpha (cairo, fill_opacity);
+    }
+    cairo_pattern_destroy(mask);
+    mask = NULL;
+  }
+
+  popTransparencyGroup();
+  cairo_restore(cairo);
+}
+
+static int luminocity(uint32_t x)
+{
+  int r = (x >> 16) & 0xff;
+  int g = (x >>  8) & 0xff;
+  int b = (x >>  0) & 0xff;
+  // an arbitrary integer approximation of .3*r + .59*g + .11*b
+  int y = (r*19661+g*38666+b*7209 + 32829)>>16;
+  return y;
+}
+
+
+/* XXX: do we need to deal with shape here? */
+void CairoOutputDev::setSoftMask(GfxState * state, double * bbox, GBool alpha,
+                                 Function * transferFunc, GfxColor * backdropColor) {
+  cairo_pattern_destroy(mask);
+
+  LOG(printf ("set softMask\n"));
+
+  if (alpha == false) {
+    /* We need to mask according to the luminocity of the group.
+     * So we paint the group to an image surface convert it to a luminocity map
+     * and then use that as the mask. */
+
+    /* Get clip extents in device space */
+    double x1, y1, x2, y2, x_min, y_min, x_max, y_max;
+    cairo_clip_extents(cairo, &x1, &y1, &x2, &y2);
+    cairo_user_to_device(cairo, &x1, &y1);
+    cairo_user_to_device(cairo, &x2, &y2);
+    x_min = MIN(x1, x2);
+    y_min = MIN(y1, y2);
+    x_max = MAX(x1, x2);
+    y_max = MAX(y1, y2);
+    cairo_clip_extents(cairo, &x1, &y1, &x2, &y2);
+    cairo_user_to_device(cairo, &x1, &y2);
+    cairo_user_to_device(cairo, &x2, &y1);
+    x_min = MIN(x_min,MIN(x1, x2));
+    y_min = MIN(y_min,MIN(y1, y2));
+    x_max = MAX(x_max,MAX(x1, x2));
+    y_max = MAX(y_max,MAX(y1, y2));
+
+    int width = (int)(ceil(x_max) - floor(x_min));
+    int height = (int)(ceil(y_max) - floor(y_min));
+
+    /* Get group device offset */
+    double x_offset, y_offset;
+    if (cairo_get_group_target(cairo) == cairo_get_target(cairo)) {
+      cairo_surface_get_device_offset(cairo_get_group_target(cairo), &x_offset, &y_offset);
+    } else {
+      cairo_surface_t *pats;
+      cairo_pattern_get_surface(group, &pats);
+      cairo_surface_get_device_offset(pats, &x_offset, &y_offset);
+    }
+
+    /* Adjust extents by group offset */
+    x_min += x_offset;
+    y_min += y_offset;
+
+    cairo_surface_t *source = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
+    cairo_t *maskCtx = cairo_create(source);
+
+    //XXX: hopefully this uses the correct color space */
+    GfxRGB backdropColorRGB;
+    groupColorSpaceStack->cs->getRGB(backdropColor, &backdropColorRGB);
+    /* paint the backdrop */
+    cairo_set_source_rgb(maskCtx,
+			 colToDbl(backdropColorRGB.r),
+			 colToDbl(backdropColorRGB.g),
+			 colToDbl(backdropColorRGB.b));
+    cairo_paint(maskCtx);
+
+    /* Copy source ctm to mask ctm and translate origin so that the
+     * mask appears it the same location on the source surface.  */
+    cairo_matrix_t mat, tmat;
+    cairo_matrix_init_translate(&tmat, -x_min, -y_min);
+    cairo_get_matrix(cairo, &mat);
+    cairo_matrix_multiply(&mat, &mat, &tmat);
+    cairo_set_matrix(maskCtx, &mat);
+
+    /* make the device offset of the new mask match that of the group */
+    cairo_surface_set_device_offset(source, x_offset, y_offset);
+
+    /* paint the group */
+    cairo_set_source(maskCtx, group);
+    cairo_paint(maskCtx);
+
+    /* XXX status = cairo_status(maskCtx); */
+    cairo_destroy(maskCtx);
+
+    /* convert to a luminocity map */
+    uint32_t *source_data = (uint32_t*)cairo_image_surface_get_data(source);
+    /* get stride in units of 32 bits */
+    int stride = cairo_image_surface_get_stride(source)/4;
+    for (int y=0; y<height; y++) {
+      for (int x=0; x<width; x++) {
+	int lum;
+	lum = luminocity(source_data[y*stride + x]);
+	if (transferFunc) {
+	  double lum_in, lum_out;
+	  lum_in = lum/256.0;
+	  transferFunc->transform(&lum_in, &lum_out);
+	  lum = (int)(lum_out * 255.0 + 0.5);
+	}
+	source_data[y*stride + x] = lum << 24;
+      }
+    }
+    cairo_surface_mark_dirty (source);
+
+    /* setup the new mask pattern */
+    mask = cairo_pattern_create_for_surface(source);
+    cairo_get_matrix(cairo, &mask_matrix);
+
+    if (cairo_get_group_target(cairo) == cairo_get_target(cairo)) {
+      cairo_pattern_set_matrix(mask, &mat);
+    } else {
+      cairo_matrix_t patMatrix;
+      cairo_pattern_get_matrix(group, &patMatrix);
+      /* Apply x_min, y_min offset to it appears in the same location as source. */
+      cairo_matrix_multiply(&patMatrix, &patMatrix, &tmat);
+      cairo_pattern_set_matrix(mask, &patMatrix);
+    }
+
+    cairo_surface_destroy(source);
+  } else {
+    mask = cairo_pattern_reference(group);
+    cairo_get_matrix(cairo, &mask_matrix);
+  }
+
+  popTransparencyGroup();
+}
+
+void CairoOutputDev::popTransparencyGroup() {
+  /* pop color space */
+  ColorSpaceStack *css = groupColorSpaceStack;
+  if (css->knockout) {
+    knockoutCount--;
+    if (!knockoutCount) {
+      /* we don't need to track the shape anymore because
+       * we are not above any knockout groups */
+      cairo_destroy(cairo_shape);
+      cairo_shape = NULL;
+    }
+  }
+  groupColorSpaceStack = css->next;
+  delete css;
+}
+
+
+void CairoOutputDev::clearSoftMask(GfxState * /*state*/) {
+  if (mask)
+    cairo_pattern_destroy(mask);
+  mask = NULL;
+}
+
+/* Taken from cairo/doc/tutorial/src/singular.c */
+static void
+get_singular_values (const cairo_matrix_t *matrix,
+		     double               *major,
+		     double               *minor)
+{
+	double xx = matrix->xx, xy = matrix->xy;
+	double yx = matrix->yx, yy = matrix->yy;
+
+	double a = xx*xx+yx*yx;
+	double b = xy*xy+yy*yy;
+	double k = xx*xy+yx*yy;
+
+	double f = (a+b) * .5;
+	double g = (a-b) * .5;
+	double delta = sqrt (g*g + k*k);
+
+	if (major)
+		*major = sqrt (f + delta);
+	if (minor)
+		*minor = sqrt (f - delta);
+}
+
+void CairoOutputDev::getScaledSize(int  orig_width,
+				   int  orig_height,
+				   int *scaledWidth,
+				   int *scaledHeight) {
+  cairo_matrix_t matrix;
+  cairo_get_matrix(cairo, &matrix);
+
+  double xScale;
+  double yScale;
+  if (orig_width > orig_height)
+    get_singular_values (&matrix, &xScale, &yScale);
+  else
+    get_singular_values (&matrix, &yScale, &xScale);
+
+  int tx, tx2, ty, ty2; /* the integer co-oridinates of the resulting image */
+  if (xScale >= 0) {
+    tx = splashRound(matrix.x0 - 0.01);
+    tx2 = splashRound(matrix.x0 + xScale + 0.01) - 1;
+  } else {
+    tx = splashRound(matrix.x0 + 0.01) - 1;
+    tx2 = splashRound(matrix.x0 + xScale - 0.01);
+  }
+  *scaledWidth = abs(tx2 - tx) + 1;
+  //scaledWidth = splashRound(fabs(xScale));
+  if (*scaledWidth == 0) {
+    // technically, this should draw nothing, but it generally seems
+    // better to draw a one-pixel-wide stripe rather than throwing it
+    // away
+    *scaledWidth = 1;
+  }
+  if (yScale >= 0) {
+    ty = splashFloor(matrix.y0 + 0.01);
+    ty2 = splashCeil(matrix.y0 + yScale - 0.01);
+  } else {
+    ty = splashCeil(matrix.y0 - 0.01);
+    ty2 = splashFloor(matrix.y0 + yScale + 0.01);
+  }
+  *scaledHeight = abs(ty2 - ty);
+  if (*scaledHeight == 0) {
+    *scaledHeight = 1;
+  }
+}
+
+cairo_surface_t *CairoOutputDev::downscaleSurface(cairo_surface_t *orig_surface) {
+  cairo_surface_t *dest_surface;
+  unsigned char *dest_buffer;
+  int dest_stride;
+  unsigned char *orig_buffer;
+  int orig_width, orig_height;
+  int orig_stride;
+  int scaledHeight;
+  int scaledWidth;
+  GBool res;
+
+  if (printing)
+    return NULL;
+
+  orig_width = cairo_image_surface_get_width (orig_surface);
+  orig_height = cairo_image_surface_get_height (orig_surface);
+  getScaledSize (orig_width, orig_height, &scaledWidth, &scaledHeight);
+  if (scaledWidth >= orig_width || scaledHeight >= orig_height)
+    return NULL;
+
+  dest_surface = cairo_surface_create_similar (orig_surface,
+					       cairo_surface_get_content (orig_surface),
+					       scaledWidth, scaledHeight);
+  dest_buffer = cairo_image_surface_get_data (dest_surface);
+  dest_stride = cairo_image_surface_get_stride (dest_surface);
+
+  orig_buffer = cairo_image_surface_get_data (orig_surface);
+  orig_stride = cairo_image_surface_get_stride (orig_surface);
+
+  res = downscale_box_filter((uint32_t *)orig_buffer,
+			     orig_stride, orig_width, orig_height,
+			     scaledWidth, scaledHeight, 0, 0,
+			     scaledWidth, scaledHeight,
+			     (uint32_t *)dest_buffer, dest_stride);
+  if (!res) {
+    cairo_surface_destroy (dest_surface);
+    return NULL;
+  }
+
+  return dest_surface;
+
+}
+
+cairo_filter_t
+CairoOutputDev::getFilterForSurface(cairo_surface_t *image,
+				    GBool interpolate)
+{
+  if (interpolate)
+    return CAIRO_FILTER_BILINEAR;
+
+  int orig_width = cairo_image_surface_get_width (image);
+  int orig_height = cairo_image_surface_get_height (image);
+  if (orig_width == 0 || orig_height == 0)
+	  return CAIRO_FILTER_NEAREST;
+
+  int scaled_width, scaled_height;
+  getScaledSize (orig_width, orig_height, &scaled_width, &scaled_height);
+
+  /* When scale factor is >= 400% we don't interpolate. See bugs #25268, #9860 */
+  if (scaled_width / orig_width >= 4 || scaled_height / orig_height >= 4)
+	  return CAIRO_FILTER_NEAREST;
+
+  return CAIRO_FILTER_BILINEAR;
+}
+
+void CairoOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
+				   int width, int height, GBool invert,
+				   GBool interpolate, GBool inlineImg) {
+
+  /* FIXME: Doesn't the image mask support any colorspace? */
+  cairo_set_source (cairo, fill_pattern);
+
+  /* work around a cairo bug when scaling 1x1 surfaces */
+  if (width == 1 && height == 1) {
+    ImageStream *imgStr;
+    Guchar pix;
+    int invert_bit;
+
+    imgStr = new ImageStream(str, width, 1, 1);
+    imgStr->reset();
+    imgStr->getPixel(&pix);
+    imgStr->close();
+    delete imgStr;
+
+    invert_bit = invert ? 1 : 0;
+    if (pix ^ invert_bit)
+      return;
+
+    cairo_save (cairo);
+    cairo_rectangle (cairo, 0., 0., width, height);
+    cairo_fill (cairo);
+    cairo_restore (cairo);
+    if (cairo_shape) {
+      cairo_save (cairo_shape);
+      cairo_rectangle (cairo_shape, 0., 0., width, height);
+      cairo_fill (cairo_shape);
+      cairo_restore (cairo_shape);
+    }
+    return;
+  }
+
+  /* shape is 1.0 for painted areas, 0.0 for unpainted ones */
+
+  cairo_matrix_t matrix;
+  cairo_get_matrix (cairo, &matrix);
+  //XXX: it is possible that we should only do sub pixel positioning if 
+  // we are rendering fonts */
+  if (!printing && prescaleImages
+      /* not rotated */
+      && matrix.xy == 0 && matrix.yx == 0
+      /* axes not flipped / not 180 deg rotated */
+      && matrix.xx > 0 && (upsideDown() ? -1 : 1) * matrix.yy > 0) {
+    drawImageMaskPrescaled(state, ref, str, width, height, invert, interpolate, inlineImg);
+  } else {
+    drawImageMaskRegular(state, ref, str, width, height, invert, interpolate, inlineImg);
+  }
+
+}
+
+void CairoOutputDev::setSoftMaskFromImageMask(GfxState *state, Object *ref, Stream *str,
+				   int width, int height, GBool invert,
+				   GBool inlineImg, double *baseMatrix) {
+
+  /* FIXME: Doesn't the image mask support any colorspace? */
+  cairo_set_source (cairo, fill_pattern);
+
+  /* work around a cairo bug when scaling 1x1 surfaces */
+  if (width == 1 && height == 1) {
+    ImageStream *imgStr;
+    Guchar pix;
+    int invert_bit;
+
+    imgStr = new ImageStream(str, width, 1, 1);
+    imgStr->reset();
+    imgStr->getPixel(&pix);
+    imgStr->close();
+    delete imgStr;
+
+    invert_bit = invert ? 1 : 0;
+    if (pix ^ invert_bit)
+      return;
+
+    cairo_save (cairo);
+    cairo_rectangle (cairo, 0., 0., width, height);
+    cairo_fill (cairo);
+    cairo_restore (cairo);
+    if (cairo_shape) {
+      cairo_save (cairo_shape);
+      cairo_rectangle (cairo_shape, 0., 0., width, height);
+      cairo_fill (cairo_shape);
+      cairo_restore (cairo_shape);
+    }
+    return;
+  }
+
+  cairo_push_group_with_content (cairo, CAIRO_CONTENT_ALPHA);
+
+  /* shape is 1.0 for painted areas, 0.0 for unpainted ones */
+
+  cairo_matrix_t matrix;
+  cairo_get_matrix (cairo, &matrix);
+  //XXX: it is possible that we should only do sub pixel positioning if 
+  // we are rendering fonts */
+  if (!printing && prescaleImages && matrix.xy == 0.0 && matrix.yx == 0.0) {
+    drawImageMaskPrescaled(state, ref, str, width, height, invert, gFalse, inlineImg);
+  } else {
+    drawImageMaskRegular(state, ref, str, width, height, invert, gFalse, inlineImg);
+  }
+
+  if (state->getFillColorSpace()->getMode() == csPattern) {
+    cairo_set_source_rgb (cairo, 1, 1, 1);
+    cairo_set_matrix (cairo, &mask_matrix);
+    cairo_mask (cairo, mask);
+  }
+
+  if (mask)
+    cairo_pattern_destroy (mask);
+  mask = cairo_pop_group (cairo);
+
+  saveState(state);
+  double bbox[4] = {0,0,1,1}; // dummy
+  beginTransparencyGroup(state, bbox, state->getFillColorSpace(),
+                         gTrue, gFalse, gFalse);
+}
+
+void CairoOutputDev::unsetSoftMaskFromImageMask(GfxState *state, double *baseMatrix) {
+  double bbox[4] = {0,0,1,1}; // dummy
+
+  endTransparencyGroup(state);
+  restoreState(state);
+  paintTransparencyGroup(state, bbox);
+  clearSoftMask(state);
+}
+
+void CairoOutputDev::drawImageMaskRegular(GfxState *state, Object *ref, Stream *str,
+					  int width, int height, GBool invert,
+					  GBool interpolate, GBool inlineImg) {
+  unsigned char *buffer;
+  unsigned char *dest;
+  cairo_surface_t *image;
+  cairo_pattern_t *pattern;
+  int x, y, i, bit;
+  ImageStream *imgStr;
+  Guchar *pix;
+  cairo_matrix_t matrix;
+  int invert_bit;
+  int row_stride;
+  cairo_filter_t filter;
+
+  /* TODO: Do we want to cache these? */
+  imgStr = new ImageStream(str, width, 1, 1);
+  imgStr->reset();
+
+  image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
+  if (cairo_surface_status (image))
+    goto cleanup;
+
+  buffer = cairo_image_surface_get_data (image);
+  row_stride = cairo_image_surface_get_stride (image);
+
+  invert_bit = invert ? 1 : 0;
+
+  for (y = 0; y < height; y++) {
+    pix = imgStr->getLine();
+    dest = buffer + y * row_stride;
+    i = 0;
+    bit = 0;
+    for (x = 0; x < width; x++) {
+      if (bit == 0)
+	dest[i] = 0;
+      if (!(pix[x] ^ invert_bit)) {
+#ifdef WORDS_BIGENDIAN
+	dest[i] |= (1 << (7 - bit));
+#else
+	dest[i] |= (1 << bit);
+#endif
+      }
+      bit++;
+      if (bit > 7) {
+	bit = 0;
+	i++;
+      }
+    }
+  }
+
+  filter = getFilterForSurface (image, interpolate);
+
+  cairo_surface_mark_dirty (image);
+  pattern = cairo_pattern_create_for_surface (image);
+  cairo_surface_destroy (image);
+  if (cairo_pattern_status (pattern))
+    goto cleanup;
+
+  LOG (printf ("drawImageMask %dx%d\n", width, height));
+
+  cairo_pattern_set_filter (pattern, filter);
+
+  if (!printing)
+    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+
+  cairo_matrix_init_translate (&matrix, 0, height);
+  cairo_matrix_scale (&matrix, width, -height);
+  cairo_pattern_set_matrix (pattern, &matrix);
+  if (cairo_pattern_status (pattern)) {
+    cairo_pattern_destroy (pattern);
+    goto cleanup;
+  }
+
+  if (state->getFillColorSpace()->getMode() == csPattern) {
+    mask = cairo_pattern_reference (pattern);
+    cairo_get_matrix (cairo, &mask_matrix);
+  } else if (!printing) {
+    cairo_save (cairo);
+    cairo_rectangle (cairo, 0., 0., 1., 1.);
+    cairo_clip (cairo);
+    cairo_mask (cairo, pattern);
+    cairo_restore (cairo);
+  } else {
+    cairo_mask (cairo, pattern);
+  }
+
+  if (cairo_shape) {
+    cairo_save (cairo_shape);
+    cairo_set_source (cairo_shape, pattern);
+    if (!printing) {
+      cairo_rectangle (cairo_shape, 0., 0., 1., 1.);
+      cairo_fill (cairo_shape);
+    } else {
+      cairo_mask (cairo_shape, pattern);
+    }
+    cairo_restore (cairo_shape);
+  }
+
+  cairo_pattern_destroy (pattern);
+
+cleanup:
+  imgStr->close();
+  delete imgStr;
+}
+
+
+void CairoOutputDev::drawImageMaskPrescaled(GfxState *state, Object *ref, Stream *str,
+					    int width, int height, GBool invert,
+					    GBool interpolate, GBool inlineImg) {
+  unsigned char *buffer;
+  cairo_surface_t *image;
+  cairo_pattern_t *pattern;
+  ImageStream *imgStr;
+  Guchar *pix;
+  cairo_matrix_t matrix;
+  int invert_bit;
+  int row_stride;
+
+  /* cairo does a very poor job of scaling down images so we scale them ourselves */
+
+  LOG (printf ("drawImageMaskPrescaled %dx%d\n", width, height));
+
+  /* this scaling code is adopted from the splash image scaling code */
+  cairo_get_matrix(cairo, &matrix);
+#if 0
+  printf("[%f %f], [%f %f], %f %f\n", matrix.xx, matrix.xy, matrix.yx, matrix.yy, matrix.x0, matrix.y0);
+#endif
+  /* this whole computation should be factored out */
+  double xScale = matrix.xx;
+  double yScale = matrix.yy;
+  int tx, tx2, ty, ty2; /* the integer co-oridinates of the resulting image */
+  int scaledHeight;
+  int scaledWidth;
+  if (xScale >= 0) {
+    tx = splashRound(matrix.x0 - 0.01);
+    tx2 = splashRound(matrix.x0 + xScale + 0.01) - 1;
+  } else {
+    tx = splashRound(matrix.x0 + 0.01) - 1;
+    tx2 = splashRound(matrix.x0 + xScale - 0.01);
+  }
+  scaledWidth = abs(tx2 - tx) + 1;
+  //scaledWidth = splashRound(fabs(xScale));
+  if (scaledWidth == 0) {
+    // technically, this should draw nothing, but it generally seems
+    // better to draw a one-pixel-wide stripe rather than throwing it
+    // away
+    scaledWidth = 1;
+  }
+  if (yScale >= 0) {
+    ty = splashFloor(matrix.y0 + 0.01);
+    ty2 = splashCeil(matrix.y0 + yScale - 0.01);
+  } else {
+    ty = splashCeil(matrix.y0 - 0.01);
+    ty2 = splashFloor(matrix.y0 + yScale + 0.01);
+  }
+  scaledHeight = abs(ty2 - ty);
+  if (scaledHeight == 0) {
+    scaledHeight = 1;
+  }
+#if 0
+  printf("xscale: %g, yscale: %g\n", xScale, yScale);
+  printf("width: %d, height: %d\n", width, height);
+  printf("scaledWidth: %d, scaledHeight: %d\n", scaledWidth, scaledHeight);
+#endif
+
+  /* compute the required padding */
+  /* Padding is used to preserve the aspect ratio.
+     We compute total_pad to make (height+total_pad)/scaledHeight as close to height/yScale as possible */
+  int head_pad = 0;
+  int tail_pad = 0;
+  int total_pad = splashRound(height*(scaledHeight/fabs(yScale)) - height);
+
+  /* compute the two pieces of padding */
+  if (total_pad > 0) {
+    //XXX: i'm not positive fabs() is correct
+    float tail_error = fabs(matrix.y0 - ty);
+    float head_error = fabs(ty2 - (matrix.y0 + yScale));
+    float tail_fraction = tail_error/(tail_error + head_error);
+    tail_pad = splashRound(total_pad*tail_fraction);
+    head_pad = total_pad - tail_pad;
+  } else {
+    tail_pad = 0;
+    head_pad = 0;
+  }
+  int origHeight = height;
+  height += tail_pad;
+  height += head_pad;
+#if 0
+  printf("head_pad: %d tail_pad: %d\n", head_pad, tail_pad);
+  printf("origHeight: %d height: %d\n", origHeight, height);
+  printf("ty: %d, ty2: %d\n", ty, ty2);
+#endif
+
+  /* TODO: Do we want to cache these? */
+  imgStr = new ImageStream(str, width, 1, 1);
+  imgStr->reset();
+
+  invert_bit = invert ? 1 : 0;
+
+  image = cairo_image_surface_create (CAIRO_FORMAT_A8, scaledWidth, scaledHeight);
+  if (cairo_surface_status (image)) {
+    imgStr->close();
+    delete imgStr;
+    return;
+  }
+
+  buffer = cairo_image_surface_get_data (image);
+  row_stride = cairo_image_surface_get_stride (image);
+
+  int yp = height / scaledHeight;
+  int yq = height % scaledHeight;
+  int xp = width / scaledWidth;
+  int xq = width % scaledWidth;
+  int yt = 0;
+  int origHeight_c = origHeight;
+  /* use MIN() because yp might be > origHeight because of padding */
+  unsigned char *pixBuf = (unsigned char *)malloc(MIN(yp+1, origHeight)*width);
+  int lastYStep = 1;
+  int total = 0;
+  for (int y = 0; y < scaledHeight; y++) {
+    // y scale Bresenham
+    int yStep = yp;
+    yt += yq;
+
+    if (yt >= scaledHeight) {
+      yt -= scaledHeight;
+      ++yStep;
+    }
+
+    // read row (s) from image ignoring the padding as appropriate
+    {
+      int n = (yp > 0) ? yStep : lastYStep;
+      total += n;
+      if (n > 0) {
+	unsigned char *p = pixBuf;
+	int head_pad_count = head_pad;
+	int origHeight_count = origHeight;
+	int tail_pad_count = tail_pad;
+	for (int i=0; i<n; i++) {
+	  // get row
+	  if (head_pad_count) {
+	    head_pad_count--;
+	  } else if (origHeight_count) {
+	    pix = imgStr->getLine();
+	    for (int j=0; j<width; j++) {
+	      if (pix[j] ^ invert_bit)
+		p[j] = 0;
+	      else
+		p[j] = 255;
+	    }
+	    origHeight_count--;
+	    p += width;
+	  } else if (tail_pad_count) {
+	    tail_pad_count--;
+	  } else {
+	    printf("%d %d\n", n, total);
+	    assert(0 && "over run\n");
+	  }
+	}
+      }
+    }
+
+    lastYStep = yStep;
+    int k1 = y;
+
+    int xt = 0;
+    int xSrc = 0;
+    int x1 = k1;
+    int n = yStep > 0 ? yStep : 1;
+    int origN = n;
+
+    /* compute the size of padding and pixels that will be used for this row */
+    int head_pad_size = MIN(n, head_pad);
+    n -= head_pad_size;
+    head_pad -= MIN(head_pad_size, yStep);
+
+    int pix_size = MIN(n, origHeight);
+    n -= pix_size;
+    origHeight -= MIN(pix_size, yStep);
+
+    int tail_pad_size = MIN(n, tail_pad);
+    n -= tail_pad_size;
+    tail_pad -= MIN(tail_pad_size, yStep);
+    if (n != 0) {
+      printf("n = %d (%d %d %d)\n", n, head_pad_size, pix_size, tail_pad_size);
+      assert(n == 0);
+    }
+
+    for (int x = 0; x < scaledWidth; ++x) {
+      int xStep = xp;
+      xt += xq;
+      if (xt >= scaledWidth) {
+	xt -= scaledWidth;
+	++xStep;
+      }
+      int m = xStep > 0 ? xStep : 1;
+      float pixAcc0 = 0;
+      /* could m * head_pad_size * tail_pad_size  overflow? */
+      if (invert_bit) {
+	pixAcc0 += m * head_pad_size * tail_pad_size * 255;
+      } else {
+	pixAcc0 += m * head_pad_size * tail_pad_size * 0;
+      }
+      /* Accumulate all of the source pixels for the destination pixel */
+      for (int i = 0; i < pix_size; ++i) {
+	for (int j = 0; j< m; ++j) {
+	  if (xSrc + i*width + j > MIN(yp + 1, origHeight_c)*width) {
+	    printf("%d > %d (%d %d %d %d) (%d %d %d)\n", xSrc + i*width + j, MIN(yp + 1, origHeight_c)*width, xSrc, i , width, j, yp, origHeight_c, width);
+	    printf("%d %d %d\n", head_pad_size, pix_size, tail_pad_size);
+	    assert(0 && "bad access\n");
+	  }
+	  pixAcc0 += pixBuf[xSrc + i*width + j];
+	}
+      }
+      buffer[y * row_stride + x] = splashFloor(pixAcc0 / (origN*m));
+      xSrc += xStep;
+      x1 += 1;
+    }
+
+  }
+  free(pixBuf);
+
+  cairo_surface_mark_dirty (image);
+  pattern = cairo_pattern_create_for_surface (image);
+  cairo_surface_destroy (image);
+  if (cairo_pattern_status (pattern)) {
+    imgStr->close();
+    delete imgStr;
+    return;
+  }
+
+  /* we should actually be using CAIRO_FILTER_NEAREST here. However,
+   * cairo doesn't yet do minifaction filtering causing scaled down
+   * images with CAIRO_FILTER_NEAREST to look really bad */
+  cairo_pattern_set_filter (pattern,
+			    interpolate ? CAIRO_FILTER_BEST : CAIRO_FILTER_FAST);
+  cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+
+  if (state->getFillColorSpace()->getMode() == csPattern) {
+    cairo_matrix_init_translate (&matrix, 0, scaledHeight);
+    cairo_matrix_scale (&matrix, scaledWidth, -scaledHeight);
+    cairo_pattern_set_matrix (pattern, &matrix);
+    if (cairo_pattern_status (pattern)) {
+      cairo_pattern_destroy (pattern);
+      imgStr->close();
+      delete imgStr;
+      return;
+    }
+
+    mask = cairo_pattern_reference (pattern);
+    cairo_get_matrix (cairo, &mask_matrix);
+  } else {
+    cairo_save (cairo);
+
+    /* modify our current transformation so that the prescaled image
+     * goes where it is supposed to */
+    cairo_get_matrix(cairo, &matrix);
+    cairo_scale(cairo, 1.0/matrix.xx, 1.0/matrix.yy);
+    // get integer co-ords
+    cairo_translate (cairo, tx - matrix.x0, ty2 - matrix.y0);
+    if (yScale > 0)
+      cairo_scale(cairo, 1, -1);
+
+    cairo_rectangle (cairo, 0., 0., scaledWidth, scaledHeight);
+    cairo_clip (cairo);
+    cairo_mask (cairo, pattern);
+
+    //cairo_get_matrix(cairo, &matrix);
+    //printf("mask at: [%f %f], [%f %f], %f %f\n\n", matrix.xx, matrix.xy, matrix.yx, matrix.yy, matrix.x0, matrix.y0);
+    cairo_restore(cairo);
+  }
+
+  if (cairo_shape) {
+    cairo_save (cairo_shape);
+
+    /* modify our current transformation so that the prescaled image
+     * goes where it is supposed to */
+    cairo_get_matrix(cairo_shape, &matrix);
+    cairo_scale(cairo_shape, 1.0/matrix.xx, 1.0/matrix.yy);
+    // get integer co-ords
+    cairo_translate (cairo_shape, tx - matrix.x0, ty2 - matrix.y0);
+    if (yScale > 0)
+      cairo_scale(cairo_shape, 1, -1);
+
+    cairo_rectangle (cairo_shape, 0., 0., scaledWidth, scaledHeight);
+    cairo_fill (cairo_shape);
+
+    cairo_restore(cairo_shape);
+  }
+
+  cairo_pattern_destroy (pattern);
+
+  imgStr->close();
+  delete imgStr;
+}
+
+void CairoOutputDev::drawMaskedImage(GfxState *state, Object *ref,
+				     Stream *str, int width, int height,
+				     GfxImageColorMap *colorMap,
+				     GBool interpolate,
+				     Stream *maskStr, int maskWidth,
+				     int maskHeight, GBool maskInvert,
+				     GBool maskInterpolate)
+{
+  ImageStream *maskImgStr, *imgStr;
+  int row_stride;
+  unsigned char *maskBuffer, *buffer;
+  unsigned char *maskDest;
+  unsigned int *dest;
+  cairo_surface_t *maskImage, *image;
+  cairo_pattern_t *maskPattern, *pattern;
+  cairo_matrix_t matrix;
+  cairo_matrix_t maskMatrix;
+  Guchar *pix;
+  int x, y;
+  int invert_bit;
+  cairo_filter_t filter;
+  cairo_filter_t maskFilter;
+
+  maskImgStr = new ImageStream(maskStr, maskWidth, 1, 1);
+  maskImgStr->reset();
+
+  maskImage = cairo_image_surface_create (CAIRO_FORMAT_A8, maskWidth, maskHeight);
+  if (cairo_surface_status (maskImage)) {
+    maskImgStr->close();
+    delete maskImgStr;
+    return;
+  }
+
+  maskBuffer = cairo_image_surface_get_data (maskImage);
+  row_stride = cairo_image_surface_get_stride (maskImage);
+
+  invert_bit = maskInvert ? 1 : 0;
+
+  for (y = 0; y < maskHeight; y++) {
+    pix = maskImgStr->getLine();
+    maskDest = maskBuffer + y * row_stride;
+    for (x = 0; x < maskWidth; x++) {
+      if (pix[x] ^ invert_bit)
+	*maskDest++ = 0;
+      else
+	*maskDest++ = 255;
+    }
+  }
+
+  maskImgStr->close();
+  delete maskImgStr;
+
+  maskFilter = getFilterForSurface (maskImage, maskInterpolate);
+
+  cairo_surface_mark_dirty (maskImage);
+  maskPattern = cairo_pattern_create_for_surface (maskImage);
+  cairo_surface_destroy (maskImage);
+  if (cairo_pattern_status (maskPattern))
+    return;
+
+#if 0
+  /* ICCBased color space doesn't do any color correction
+   * so check its underlying color space as well */
+  int is_identity_transform;
+  is_identity_transform = colorMap->getColorSpace()->getMode() == csDeviceRGB ||
+		  (colorMap->getColorSpace()->getMode() == csICCBased && 
+		   ((GfxICCBasedColorSpace*)colorMap->getColorSpace())->getAlt()->getMode() == csDeviceRGB);
+#endif
+
+  /* TODO: Do we want to cache these? */
+  imgStr = new ImageStream(str, width,
+			   colorMap->getNumPixelComps(),
+			   colorMap->getBits());
+  imgStr->reset();
+
+  image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, height);
+  if (cairo_surface_status (image))
+    goto cleanup;
+
+  buffer = cairo_image_surface_get_data (image);
+  row_stride = cairo_image_surface_get_stride (image);
+  for (y = 0; y < height; y++) {
+    dest = (unsigned int *) (buffer + y * row_stride);
+    pix = imgStr->getLine();
+    colorMap->getRGBLine (pix, dest, width);
+  }
+
+  filter = getFilterForSurface (image, interpolate);
+
+  cairo_surface_mark_dirty (image);
+  pattern = cairo_pattern_create_for_surface (image);
+  cairo_surface_destroy (image);
+  if (cairo_pattern_status (pattern))
+    goto cleanup;
+
+  LOG (printf ("drawMaskedImage %dx%d\n", width, height));
+
+  cairo_pattern_set_filter (pattern, filter);
+  cairo_pattern_set_filter (maskPattern, maskFilter);
+
+  if (!printing) {
+    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+    cairo_pattern_set_extend (maskPattern, CAIRO_EXTEND_PAD);
+  }
+
+  cairo_matrix_init_translate (&matrix, 0, height);
+  cairo_matrix_scale (&matrix, width, -height);
+  cairo_pattern_set_matrix (pattern, &matrix);
+  if (cairo_pattern_status (pattern)) {
+    cairo_pattern_destroy (pattern);
+    cairo_pattern_destroy (maskPattern);
+    goto cleanup;
+  }
+
+  cairo_matrix_init_translate (&maskMatrix, 0, maskHeight);
+  cairo_matrix_scale (&maskMatrix, maskWidth, -maskHeight);
+  cairo_pattern_set_matrix (maskPattern, &maskMatrix);
+  if (cairo_pattern_status (maskPattern)) {
+    cairo_pattern_destroy (maskPattern);
+    cairo_pattern_destroy (pattern);
+    goto cleanup;
+  }
+
+  if (!printing) {
+    cairo_save (cairo);
+    cairo_set_source (cairo, pattern);
+    cairo_rectangle (cairo, 0., 0., 1., 1.);
+    cairo_clip (cairo);
+    cairo_mask (cairo, maskPattern);
+    cairo_restore (cairo);
+  } else {
+    cairo_set_source (cairo, pattern);
+    cairo_mask (cairo, maskPattern);
+  }
+
+  if (cairo_shape) {
+    cairo_save (cairo_shape);
+    cairo_set_source (cairo_shape, pattern);
+    if (!printing) {
+      cairo_rectangle (cairo_shape, 0., 0., 1., 1.);
+      cairo_fill (cairo_shape);
+    } else {
+      cairo_mask (cairo_shape, pattern);
+    }
+    cairo_restore (cairo_shape);
+  }
+
+  cairo_pattern_destroy (maskPattern);
+  cairo_pattern_destroy (pattern);
+
+cleanup:
+  imgStr->close();
+  delete imgStr;
+}
+
+
+//XXX: is this affect by AIS(alpha is shape)?
+void CairoOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
+					 int width, int height,
+					 GfxImageColorMap *colorMap,
+					 GBool interpolate,
+					 Stream *maskStr,
+					 int maskWidth, int maskHeight,
+					 GfxImageColorMap *maskColorMap,
+					 GBool maskInterpolate)
+{
+  ImageStream *maskImgStr, *imgStr;
+  int row_stride;
+  unsigned char *maskBuffer, *buffer;
+  unsigned char *maskDest;
+  unsigned int *dest;
+  cairo_surface_t *maskImage, *image;
+  cairo_pattern_t *maskPattern, *pattern;
+  cairo_matrix_t maskMatrix, matrix;
+  Guchar *pix;
+  int y;
+  cairo_filter_t filter;
+  cairo_filter_t maskFilter;
+
+  maskImgStr = new ImageStream(maskStr, maskWidth,
+			       maskColorMap->getNumPixelComps(),
+			       maskColorMap->getBits());
+  maskImgStr->reset();
+
+  maskImage = cairo_image_surface_create (CAIRO_FORMAT_A8, maskWidth, maskHeight);
+  if (cairo_surface_status (maskImage)) {
+    maskImgStr->close();
+    delete maskImgStr;
+    return;
+  }
+
+  maskBuffer = cairo_image_surface_get_data (maskImage);
+  row_stride = cairo_image_surface_get_stride (maskImage);
+  for (y = 0; y < maskHeight; y++) {
+    maskDest = (unsigned char *) (maskBuffer + y * row_stride);
+    pix = maskImgStr->getLine();
+    maskColorMap->getGrayLine (pix, maskDest, maskWidth);
+  }
+
+  maskImgStr->close();
+  delete maskImgStr;
+
+  maskFilter = getFilterForSurface (maskImage, maskInterpolate);
+
+  cairo_surface_mark_dirty (maskImage);
+  maskPattern = cairo_pattern_create_for_surface (maskImage);
+  cairo_surface_destroy (maskImage);
+  if (cairo_pattern_status (maskPattern))
+    return;
+
+#if 0
+  /* ICCBased color space doesn't do any color correction
+   * so check its underlying color space as well */
+  int is_identity_transform;
+  is_identity_transform = colorMap->getColorSpace()->getMode() == csDeviceRGB ||
+		  (colorMap->getColorSpace()->getMode() == csICCBased &&
+		   ((GfxICCBasedColorSpace*)colorMap->getColorSpace())->getAlt()->getMode() == csDeviceRGB);
+#endif
+
+  /* TODO: Do we want to cache these? */
+  imgStr = new ImageStream(str, width,
+			   colorMap->getNumPixelComps(),
+			   colorMap->getBits());
+  imgStr->reset();
+
+  image = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, height);
+  if (cairo_surface_status (image))
+    goto cleanup;
+
+  buffer = cairo_image_surface_get_data (image);
+  row_stride = cairo_image_surface_get_stride (image);
+  for (y = 0; y < height; y++) {
+    dest = (unsigned int *) (buffer + y * row_stride);
+    pix = imgStr->getLine();
+    colorMap->getRGBLine (pix, dest, width);
+  }
+
+  filter = getFilterForSurface (image, interpolate);
+
+  cairo_surface_mark_dirty (image);
+
+  setMimeData(str, ref, image);
+
+  pattern = cairo_pattern_create_for_surface (image);
+  cairo_surface_destroy (image);
+  if (cairo_pattern_status (pattern))
+    goto cleanup;
+
+  LOG (printf ("drawSoftMaskedImage %dx%d\n", width, height));
+
+  cairo_pattern_set_filter (pattern, filter);
+  cairo_pattern_set_filter (maskPattern, maskFilter);
+
+  if (!printing) {
+    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+    cairo_pattern_set_extend (maskPattern, CAIRO_EXTEND_PAD);
+  }
+
+  cairo_matrix_init_translate (&matrix, 0, height);
+  cairo_matrix_scale (&matrix, width, -height);
+  cairo_pattern_set_matrix (pattern, &matrix);
+  if (cairo_pattern_status (pattern)) {
+    cairo_pattern_destroy (pattern);
+    cairo_pattern_destroy (maskPattern);
+    goto cleanup;
+  }
+
+  cairo_matrix_init_translate (&maskMatrix, 0, maskHeight);
+  cairo_matrix_scale (&maskMatrix, maskWidth, -maskHeight);
+  cairo_pattern_set_matrix (maskPattern, &maskMatrix);
+  if (cairo_pattern_status (maskPattern)) {
+    cairo_pattern_destroy (maskPattern);
+    cairo_pattern_destroy (pattern);
+    goto cleanup;
+  }
+
+  if (fill_opacity != 1.0)
+    cairo_push_group (cairo);
+  else
+    cairo_save (cairo);
+
+  cairo_set_source (cairo, pattern);
+  if (!printing) {
+    cairo_rectangle (cairo, 0., 0.,
+		     MIN (width, maskWidth) / (double)width,
+		     MIN (height, maskHeight) / (double)height);
+    cairo_clip (cairo);
+  }
+  cairo_mask (cairo, maskPattern);
+
+  if (fill_opacity != 1.0) {
+    cairo_pop_group_to_source (cairo);
+    cairo_save (cairo);
+    if (!printing) {
+      cairo_rectangle (cairo, 0., 0.,
+		       MIN (width, maskWidth) / (double)width,
+		       MIN (height, maskHeight) / (double)height);
+      cairo_clip (cairo);
+    }
+    cairo_paint_with_alpha (cairo, fill_opacity);
+  }
+  cairo_restore (cairo);
+
+  if (cairo_shape) {
+    cairo_save (cairo_shape);
+    cairo_set_source (cairo_shape, pattern);
+    if (!printing) {
+      cairo_rectangle (cairo_shape, 0., 0.,
+		       MIN (width, maskWidth) / (double)width,
+		       MIN (height, maskHeight) / (double)height);
+      cairo_fill (cairo_shape);
+    } else {
+      cairo_mask (cairo_shape, pattern);
+    }
+    cairo_restore (cairo_shape);
+  }
+
+  cairo_pattern_destroy (maskPattern);
+  cairo_pattern_destroy (pattern);
+
+cleanup:
+  imgStr->close();
+  delete imgStr;
+}
+
+GBool CairoOutputDev::getStreamData (Stream *str, char **buffer, int *length)
+{
+  int len, i;
+  char *strBuffer;
+
+  len = 0;
+  str->close();
+  str->reset();
+  while (str->getChar() != EOF) len++;
+  if (len == 0)
+    return gFalse;
+
+  strBuffer = (char *)gmalloc (len);
+
+  str->close();
+  str->reset();
+  for (i = 0; i < len; ++i)
+    strBuffer[i] = str->getChar();
+
+  *buffer = strBuffer;
+  *length = len;
+
+  return gTrue;
+}
+
+void CairoOutputDev::setMimeData(Stream *str, Object *ref, cairo_surface_t *image)
+{
+  char *strBuffer;
+  int len;
+  Object obj;
+
+  if (!printing || !(str->getKind() == strDCT || str->getKind() == strJPX))
+    return;
+
+  // colorspace in stream dict may be different from colorspace in jpx
+  // data
+  if (str->getKind() == strJPX) {
+    GBool hasColorSpace = !str->getDict()->lookup("ColorSpace", &obj)->isNull();
+    obj.free();
+    if (hasColorSpace)
+      return;
+  }
+
+  if (getStreamData (str->getNextStream(), &strBuffer, &len)) {
+    cairo_status_t st;
+
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 11, 2)
+    if (ref && ref->isRef()) {
+      Ref imgRef = ref->getRef();
+      GooString *surfaceId = new GooString("poppler-surface-");
+      surfaceId->appendf("{0:d}-{1:d}", imgRef.gen, imgRef.num);
+      char *idBuffer = copyString(surfaceId->getCString());
+      st = cairo_surface_set_mime_data (image, CAIRO_MIME_TYPE_UNIQUE_ID,
+                                        (const unsigned char *)idBuffer,
+                                        surfaceId->getLength(),
+                                        gfree, idBuffer);
+      if (st)
+        gfree(idBuffer);
+      delete surfaceId;
+    }
+#endif
+
+    st = cairo_surface_set_mime_data (image,
+				      str->getKind() == strDCT ?
+				      CAIRO_MIME_TYPE_JPEG : CAIRO_MIME_TYPE_JP2,
+				      (const unsigned char *)strBuffer, len,
+				      gfree, strBuffer);
+    if (st)
+      gfree (strBuffer);
+  }
+}
+
+void CairoOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
+			       int width, int height,
+			       GfxImageColorMap *colorMap,
+			       GBool interpolate,
+			       int *maskColors, GBool inlineImg)
+{
+  cairo_surface_t *image;
+  cairo_pattern_t *pattern, *maskPattern;
+  ImageStream *imgStr;
+  cairo_matrix_t matrix;
+  unsigned char *buffer;
+  int stride, i;
+  GfxRGB *lookup = NULL;
+  cairo_filter_t filter = CAIRO_FILTER_BILINEAR;
+
+  /* TODO: Do we want to cache these? */
+  imgStr = new ImageStream(str, width,
+			   colorMap->getNumPixelComps(),
+			   colorMap->getBits());
+  imgStr->reset();
+
+#if 0
+  /* ICCBased color space doesn't do any color correction
+   * so check its underlying color space as well */
+  int is_identity_transform;
+  is_identity_transform = colorMap->getColorSpace()->getMode() == csDeviceRGB ||
+		  (colorMap->getColorSpace()->getMode() == csICCBased &&
+		   ((GfxICCBasedColorSpace*)colorMap->getColorSpace())->getAlt()->getMode() == csDeviceRGB);
+#endif
+
+  image = cairo_image_surface_create (maskColors ?
+				      CAIRO_FORMAT_ARGB32 :
+				      CAIRO_FORMAT_RGB24,
+				      width, height);
+  if (cairo_surface_status (image))
+    goto cleanup;
+
+  // special case for one-channel (monochrome/gray/separation) images:
+  // build a lookup table here
+  if (colorMap->getNumPixelComps() == 1) {
+    int n;
+    Guchar pix;
+
+    n = 1 << colorMap->getBits();
+    lookup = (GfxRGB *)gmallocn(n, sizeof(GfxRGB));
+    for (i = 0; i < n; ++i) {
+      pix = (Guchar)i;
+
+      colorMap->getRGB(&pix, &lookup[i]);
+    }
+  }
+
+  buffer = cairo_image_surface_get_data (image);
+  stride = cairo_image_surface_get_stride (image);
+  for (int y = 0; y < height; y++) {
+    uint32_t *dest = (uint32_t *) (buffer + y * stride);
+    Guchar *pix = imgStr->getLine();
+
+    if (lookup) {
+      Guchar *p = pix;
+      GfxRGB rgb;
+
+      for (i = 0; i < width; i++) {
+        rgb = lookup[*p];
+        dest[i] =
+		((int) colToByte(rgb.r) << 16) |
+		((int) colToByte(rgb.g) << 8) |
+		((int) colToByte(rgb.b) << 0);
+	p++;
+      }
+    } else {
+      colorMap->getRGBLine (pix, dest, width);
+    }
+
+    if (maskColors) {
+      for (int x = 0; x < width; x++) {
+	bool is_opaque = false;
+	for (int i = 0; i < colorMap->getNumPixelComps(); ++i) {
+	  if (pix[i] < maskColors[2*i] ||
+	      pix[i] > maskColors[2*i+1]) {
+	    is_opaque = true;
+	    break;
+	  }
+	}
+	if (is_opaque)
+	  *dest |= 0xff000000;
+	else
+	  *dest = 0;
+	dest++;
+	pix += colorMap->getNumPixelComps();
+      }
+    }
+  }
+  gfree(lookup);
+
+  LOG (printf ("drawImage %dx%d\n", width, height));
+
+  cairo_surface_t *scaled_surface;
+
+  scaled_surface = downscaleSurface (image);
+  if (scaled_surface) {
+    if (cairo_surface_status (scaled_surface))
+      goto cleanup;
+    cairo_surface_destroy (image);
+    image = scaled_surface;
+    width = cairo_image_surface_get_width (image);
+    height = cairo_image_surface_get_height (image);
+  } else {
+    filter = getFilterForSurface (image, interpolate);
+  }
+
+  cairo_surface_mark_dirty (image);
+
+  if (!inlineImg) /* don't read stream twice if it is an inline image */
+    setMimeData(str, ref, image);
+
+  pattern = cairo_pattern_create_for_surface (image);
+  cairo_surface_destroy (image);
+  if (cairo_pattern_status (pattern))
+    goto cleanup;
+
+  cairo_pattern_set_filter (pattern, filter);
+
+  if (!printing)
+    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
+
+  cairo_matrix_init_translate (&matrix, 0, height);
+  cairo_matrix_scale (&matrix, width, -height);
+  cairo_pattern_set_matrix (pattern, &matrix);
+  if (cairo_pattern_status (pattern)) {
+    cairo_pattern_destroy (pattern);
+    goto cleanup;
+  }
+
+  if (!mask && fill_opacity != 1.0) {
+    maskPattern = cairo_pattern_create_rgba (1., 1., 1., fill_opacity);
+  } else if (mask) {
+    maskPattern = cairo_pattern_reference (mask);
+  } else {
+    maskPattern = NULL;
+  }
+
+  cairo_save (cairo);
+  cairo_set_source (cairo, pattern);
+  if (!printing)
+    cairo_rectangle (cairo, 0., 0., 1., 1.);
+  if (maskPattern) {
+    if (!printing)
+      cairo_clip (cairo);
+    cairo_set_matrix (cairo, &mask_matrix);
+    cairo_mask (cairo, maskPattern);
+  } else {
+    if (printing)
+      cairo_paint (cairo);
+    else
+      cairo_fill (cairo);
+  }
+  cairo_restore (cairo);
+
+  cairo_pattern_destroy (maskPattern);
+
+  if (cairo_shape) {
+    cairo_save (cairo_shape);
+    cairo_set_source (cairo_shape, pattern);
+    if (printing) {
+      cairo_paint (cairo_shape);
+    } else {
+      cairo_rectangle (cairo_shape, 0., 0., 1., 1.);
+      cairo_fill (cairo_shape);
+    }
+    cairo_restore (cairo_shape);
+  }
+
+  cairo_pattern_destroy (pattern);
+
+cleanup:
+  imgStr->close();
+  delete imgStr;
+}
+
+
+//------------------------------------------------------------------------
+// ImageOutputDev
+//------------------------------------------------------------------------
+
+CairoImageOutputDev::CairoImageOutputDev()
+{
+  images = NULL;
+  numImages = 0;
+  size = 0;
+  imgDrawCbk = NULL;
+  imgDrawCbkData = NULL;
+}
+
+CairoImageOutputDev::~CairoImageOutputDev()
+{
+  int i;
+
+  for (i = 0; i < numImages; i++)
+    delete images[i];
+  gfree (images);
+}
+
+void CairoImageOutputDev::saveImage(CairoImage *image)
+{ 
+  if (numImages >= size) {
+	  size += 16;
+	  images = (CairoImage **) greallocn (images, size, sizeof (CairoImage *));
+  }
+  images[numImages++] = image;
+}	
+
+void CairoImageOutputDev::drawImageMask(GfxState *state, Object *ref, Stream *str,
+					int width, int height, GBool invert,
+					GBool interpolate, GBool inlineImg)
+{
+  cairo_t *cr;
+  cairo_surface_t *surface;
+  double x1, y1, x2, y2;
+  double *ctm;
+  double mat[6];
+  CairoImage *image;
+
+  ctm = state->getCTM();
+  
+  mat[0] = ctm[0];
+  mat[1] = ctm[1];
+  mat[2] = -ctm[2];
+  mat[3] = -ctm[3];
+  mat[4] = ctm[2] + ctm[4];
+  mat[5] = ctm[3] + ctm[5];
+  x1 = mat[4];
+  y1 = mat[5];
+  x2 = x1 + width;
+  y2 = y1 + height;
+
+  image = new CairoImage (x1, y1, x2, y2);
+  saveImage (image);
+
+  if (imgDrawCbk && imgDrawCbk (numImages - 1, imgDrawCbkData)) {
+    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+    cr = cairo_create (surface);
+    setCairo (cr);
+    cairo_translate (cr, 0, height);
+    cairo_scale (cr, width, -height);
+
+    CairoOutputDev::drawImageMask(state, ref, str, width, height, invert, interpolate, inlineImg);
+    image->setImage (surface);
+
+    setCairo (NULL);
+    cairo_surface_destroy (surface);
+    cairo_destroy (cr);
+  }
+}
+
+void CairoImageOutputDev::drawImage(GfxState *state, Object *ref, Stream *str,
+				    int width, int height, GfxImageColorMap *colorMap,
+				    GBool interpolate, int *maskColors, GBool inlineImg)
+{
+  cairo_t *cr;
+  cairo_surface_t *surface;
+  double x1, y1, x2, y2;
+  double *ctm;
+  double mat[6];
+  CairoImage *image;
+
+  ctm = state->getCTM();
+  
+  mat[0] = ctm[0];
+  mat[1] = ctm[1];
+  mat[2] = -ctm[2];
+  mat[3] = -ctm[3];
+  mat[4] = ctm[2] + ctm[4];
+  mat[5] = ctm[3] + ctm[5];
+  x1 = mat[4];
+  y1 = mat[5];
+  x2 = x1 + width;
+  y2 = y1 + height;
+
+  image = new CairoImage (x1, y1, x2, y2);
+  saveImage (image);
+
+  if (imgDrawCbk && imgDrawCbk (numImages - 1, imgDrawCbkData)) {
+    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+    cr = cairo_create (surface);
+    setCairo (cr);
+    cairo_translate (cr, 0, height);
+    cairo_scale (cr, width, -height);
+    
+    CairoOutputDev::drawImage(state, ref, str, width, height, colorMap, interpolate, maskColors, inlineImg);
+    image->setImage (surface);
+    
+    setCairo (NULL);
+    cairo_surface_destroy (surface);
+    cairo_destroy (cr);
+  }
+}
+
+void CairoImageOutputDev::drawSoftMaskedImage(GfxState *state, Object *ref, Stream *str,
+					      int width, int height,
+					      GfxImageColorMap *colorMap,
+					      GBool interpolate,
+					      Stream *maskStr,
+					      int maskWidth, int maskHeight,
+					      GfxImageColorMap *maskColorMap,
+					      GBool maskInterpolate)
+{
+  cairo_t *cr;
+  cairo_surface_t *surface;
+  double x1, y1, x2, y2;
+  double *ctm;
+  double mat[6];
+  CairoImage *image;
+
+  ctm = state->getCTM();
+  
+  mat[0] = ctm[0];
+  mat[1] = ctm[1];
+  mat[2] = -ctm[2];
+  mat[3] = -ctm[3];
+  mat[4] = ctm[2] + ctm[4];
+  mat[5] = ctm[3] + ctm[5];
+  x1 = mat[4];
+  y1 = mat[5];
+  x2 = x1 + width;
+  y2 = y1 + height;
+
+  image = new CairoImage (x1, y1, x2, y2);
+  saveImage (image);
+
+  if (imgDrawCbk && imgDrawCbk (numImages - 1, imgDrawCbkData)) {
+    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+    cr = cairo_create (surface);
+    setCairo (cr);
+    cairo_translate (cr, 0, height);
+    cairo_scale (cr, width, -height);
+    
+    CairoOutputDev::drawSoftMaskedImage(state, ref, str, width, height, colorMap, interpolate,
+					maskStr, maskWidth, maskHeight, maskColorMap, maskInterpolate);
+    image->setImage (surface);
+    
+    setCairo (NULL);
+    cairo_surface_destroy (surface);
+    cairo_destroy (cr);
+  }
+}
+
+void CairoImageOutputDev::drawMaskedImage(GfxState *state, Object *ref, Stream *str,
+					  int width, int height,
+					  GfxImageColorMap *colorMap,
+					  GBool interpolate,
+					  Stream *maskStr,
+					  int maskWidth, int maskHeight,
+					  GBool maskInvert, GBool maskInterpolate)
+{
+  cairo_t *cr;
+  cairo_surface_t *surface;
+  double x1, y1, x2, y2;
+  double *ctm;
+  double mat[6];
+  CairoImage *image;
+
+  ctm = state->getCTM();
+  
+  mat[0] = ctm[0];
+  mat[1] = ctm[1];
+  mat[2] = -ctm[2];
+  mat[3] = -ctm[3];
+  mat[4] = ctm[2] + ctm[4];
+  mat[5] = ctm[3] + ctm[5];
+  x1 = mat[4];
+  y1 = mat[5];
+  x2 = x1 + width;
+  y2 = y1 + height;
+
+  image = new CairoImage (x1, y1, x2, y2);
+  saveImage (image);
+
+  if (imgDrawCbk && imgDrawCbk (numImages - 1, imgDrawCbkData)) {
+    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
+    cr = cairo_create (surface);
+    setCairo (cr);
+    cairo_translate (cr, 0, height);
+    cairo_scale (cr, width, -height);
+    
+    CairoOutputDev::drawMaskedImage(state, ref, str, width, height, colorMap, interpolate,
+				    maskStr, maskWidth, maskHeight, maskInvert, maskInterpolate);
+    image->setImage (surface);
+    
+    setCairo (NULL);
+    cairo_surface_destroy (surface);
+    cairo_destroy (cr);
+  }
+}

=== modified file '.pc/ltmain-as-needed.diff/ltmain.sh'
--- .pc/ltmain-as-needed.diff/ltmain.sh	2012-02-12 22:49:35 +0000
+++ .pc/ltmain-as-needed.diff/ltmain.sh	2012-11-16 16:39:27 +0000
@@ -70,7 +70,7 @@
 #         compiler:		$LTCC
 #         compiler flags:		$LTCFLAGS
 #         linker:		$LD (gnu? $with_gnu_ld)
-#         $progname:	(GNU libtool) 2.4.2
+#         $progname:	(GNU libtool) 2.4.2 Debian-2.4.2-1ubuntu1
 #         automake:	$automake_version
 #         autoconf:	$autoconf_version
 #
@@ -80,7 +80,7 @@
 
 PROGRAM=libtool
 PACKAGE=libtool
-VERSION=2.4.2
+VERSION="2.4.2 Debian-2.4.2-1ubuntu1"
 TIMESTAMP=""
 package_revision=1.3337
 
@@ -6124,7 +6124,10 @@
 	case $pass in
 	dlopen) libs="$dlfiles" ;;
 	dlpreopen) libs="$dlprefiles" ;;
-	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+	link)
+	  libs="$deplibs %DEPLIBS%"
+	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+	  ;;
 	esac
       fi
       if test "$linkmode,$pass" = "lib,dlpreopen"; then
@@ -6444,19 +6447,19 @@
 	    # It is a libtool convenience library, so add in its objects.
 	    func_append convenience " $ladir/$objdir/$old_library"
 	    func_append old_convenience " $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+	      if $opt_preserve_dup_deps ; then
+		case "$tmp_libs " in
+		*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+		esac
+	      fi
+	      func_append tmp_libs " $deplib"
+	    done
 	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
 	    func_fatal_error "\`$lib' is not a convenience library"
 	  fi
-	  tmp_libs=
-	  for deplib in $dependency_libs; do
-	    deplibs="$deplib $deplibs"
-	    if $opt_preserve_dup_deps ; then
-	      case "$tmp_libs " in
-	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
-	      esac
-	    fi
-	    func_append tmp_libs " $deplib"
-	  done
 	  continue
 	fi # $pass = conv
 
@@ -7349,6 +7352,9 @@
 	    revision="$number_minor"
 	    lt_irix_increment=no
 	    ;;
+	  *)
+	    func_fatal_configuration "$modename: unknown library version type \`$version_type'"
+	    ;;
 	  esac
 	  ;;
 	no)

=== added directory '.pc/qt4-visibility.diff'
=== added directory '.pc/qt4-visibility.diff/qt4'
=== added directory '.pc/qt4-visibility.diff/qt4/src'
=== added file '.pc/qt4-visibility.diff/qt4/src/Makefile.am'
--- .pc/qt4-visibility.diff/qt4/src/Makefile.am	1970-01-01 00:00:00 +0000
+++ .pc/qt4-visibility.diff/qt4/src/Makefile.am	2012-11-16 16:39:27 +0000
@@ -0,0 +1,74 @@
+INCLUDES =					\
+	-I$(top_srcdir)				\
+	-I$(top_srcdir)/poppler			\
+	$(FONTCONFIG_CFLAGS)			\
+	$(POPPLER_QT4_CFLAGS)
+
+SUFFIXES: .moc
+
+poppler_includedir = $(includedir)/poppler/qt4
+
+poppler_include_HEADERS =			\
+	poppler-qt4.h				\
+	poppler-link.h				\
+	poppler-annotation.h			\
+	poppler-form.h				\
+	poppler-optcontent.h			\
+	poppler-export.h			\
+	poppler-media.h				\
+	poppler-page-transition.h
+
+lib_LTLIBRARIES = libpoppler-qt4.la
+
+libpoppler_qt4_la_SOURCES =			\
+	poppler-document.cc			\
+	poppler-page.cc				\
+	poppler-fontinfo.cc			\
+	poppler-embeddedfile.cc			\
+	poppler-textbox.cc			\
+	poppler-link.cc				\
+	poppler-annotation.cc			\
+	poppler-link-extractor.cc		\
+	poppler-optcontent.cc			\
+	poppler-optcontent.h			\
+	poppler-page-transition.cc		\
+	poppler-sound.cc			\
+	poppler-form.cc				\
+	poppler-base-converter.cc		\
+	poppler-ps-converter.cc			\
+	poppler-pdf-converter.cc		\
+	poppler-qiodeviceoutstream.cc		\
+	poppler-private.cc			\
+	poppler-movie.cc			\
+	poppler-media.cc			\
+	poppler-annotation-helper.h		\
+	poppler-page-private.h			\
+	poppler-link-extractor-private.h	\
+	poppler-annotation-private.h		\
+	poppler-converter-private.h		\
+	poppler-qiodeviceoutstream-private.h	\
+	poppler-optcontent-private.h		\
+	poppler-export.h			\
+	poppler-private.h			\
+	poppler-page-transition-private.h	\
+	poppler-embeddedfile-private.h
+
+libpoppler_qt4_la_CXXFLAGS = 			\
+	-Dpoppler_qt4_EXPORTS
+
+libpoppler_qt4_la_LIBADD = 			\
+	$(top_builddir)/poppler/libpoppler.la	\
+	$(top_builddir)/poppler/libpoppler-arthur.la	\
+	$(FONTCONFIG_LIBS)				\
+	$(POPPLER_QT4_LIBS)
+
+libpoppler_qt4_la_LDFLAGS = -version-info 4:0:0 @create_shared_lib@ @auto_import_flags@
+
+# This rule lets GNU make create any *.moc from the equivalent *.h
+.h.moc:
+	$(AM_V_GEN) $(MOCQT4) -i $< -o $@
+
+BUILT_SOURCES = poppler-optcontent.moc
+
+clean-generic:
+	rm -f *.moc

=== added file '.pc/qt4-visibility.diff/qt4/src/Makefile.in'
--- .pc/qt4-visibility.diff/qt4/src/Makefile.in	1970-01-01 00:00:00 +0000
+++ .pc/qt4-visibility.diff/qt4/src/Makefile.in	2012-11-16 16:39:27 +0000
@@ -0,0 +1,948 @@
+# Makefile.in generated by automake 1.11.5 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
+# Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+am__make_dryrun = \
+  { \
+    am__dry=no; \
+    case $$MAKEFLAGS in \
+      *\\[\ \	]*) \
+        echo 'am--echo: ; @echo "AM"  OK' | $(MAKE) -f - 2>/dev/null \
+          | grep '^AM OK$$' >/dev/null || am__dry=yes;; \
+      *) \
+        for am__flg in $$MAKEFLAGS; do \
+          case $$am__flg in \
+            *=*|--*) ;; \
+            *n*) am__dry=yes; break;; \
+          esac; \
+        done;; \
+    esac; \
+    test $$am__dry = yes; \
+  }
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = qt4/src
+DIST_COMMON = $(poppler_include_HEADERS) $(srcdir)/Makefile.am \
+	$(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/acx_pthread.m4 \
+	$(top_srcdir)/m4/define-dir.m4 $(top_srcdir)/m4/gtk-doc.m4 \
+	$(top_srcdir)/m4/iconv.m4 $(top_srcdir)/m4/introspection.m4 \
+	$(top_srcdir)/m4/libjpeg.m4 $(top_srcdir)/m4/libtool.m4 \
+	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
+	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(install_sh) -d
+CONFIG_HEADER = $(top_builddir)/config.h \
+	$(top_builddir)/poppler/poppler-config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__uninstall_files_from_dir = { \
+  test -z "$$files" \
+    || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
+    || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
+         $(am__cd) "$$dir" && rm -f $$files; }; \
+  }
+am__installdirs = "$(DESTDIR)$(libdir)" \
+	"$(DESTDIR)$(poppler_includedir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+am__DEPENDENCIES_1 =
+libpoppler_qt4_la_DEPENDENCIES =  \
+	$(top_builddir)/poppler/libpoppler.la \
+	$(top_builddir)/poppler/libpoppler-arthur.la \
+	$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
+am_libpoppler_qt4_la_OBJECTS = libpoppler_qt4_la-poppler-document.lo \
+	libpoppler_qt4_la-poppler-page.lo \
+	libpoppler_qt4_la-poppler-fontinfo.lo \
+	libpoppler_qt4_la-poppler-embeddedfile.lo \
+	libpoppler_qt4_la-poppler-textbox.lo \
+	libpoppler_qt4_la-poppler-link.lo \
+	libpoppler_qt4_la-poppler-annotation.lo \
+	libpoppler_qt4_la-poppler-link-extractor.lo \
+	libpoppler_qt4_la-poppler-optcontent.lo \
+	libpoppler_qt4_la-poppler-page-transition.lo \
+	libpoppler_qt4_la-poppler-sound.lo \
+	libpoppler_qt4_la-poppler-form.lo \
+	libpoppler_qt4_la-poppler-base-converter.lo \
+	libpoppler_qt4_la-poppler-ps-converter.lo \
+	libpoppler_qt4_la-poppler-pdf-converter.lo \
+	libpoppler_qt4_la-poppler-qiodeviceoutstream.lo \
+	libpoppler_qt4_la-poppler-private.lo \
+	libpoppler_qt4_la-poppler-movie.lo \
+	libpoppler_qt4_la-poppler-media.lo
+libpoppler_qt4_la_OBJECTS = $(am_libpoppler_qt4_la_OBJECTS)
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+libpoppler_qt4_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+	$(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) \
+	$(libpoppler_qt4_la_LDFLAGS) $(LDFLAGS) -o $@
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) -I$(top_builddir)/poppler
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo "  CXX   " $@;
+AM_V_at = $(am__v_at_@AM_V@)
+am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
+am__v_at_0 = @
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo "  CXXLD " $@;
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_@AM_V@)
+am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
+am__v_CC_0 = @echo "  CC    " $@;
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_@AM_V@)
+am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
+am__v_CCLD_0 = @echo "  CCLD  " $@;
+AM_V_GEN = $(am__v_GEN_@AM_V@)
+am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
+am__v_GEN_0 = @echo "  GEN   " $@;
+SOURCES = $(libpoppler_qt4_la_SOURCES)
+DIST_SOURCES = $(libpoppler_qt4_la_SOURCES)
+am__can_run_installinfo = \
+  case $$AM_UPDATE_INFO_DIR in \
+    n|no|NO) false;; \
+    *) (install-info --version) >/dev/null 2>&1;; \
+  esac
+HEADERS = $(poppler_include_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CAIRO_CFLAGS = @CAIRO_CFLAGS@
+CAIRO_FEATURE = @CAIRO_FEATURE@
+CAIRO_LIBS = @CAIRO_LIBS@
+CAIRO_REQ = @CAIRO_REQ@
+CAIRO_VERSION = @CAIRO_VERSION@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+FONTCONFIG_CFLAGS = @FONTCONFIG_CFLAGS@
+FONTCONFIG_LIBS = @FONTCONFIG_LIBS@
+FREETYPE_CFLAGS = @FREETYPE_CFLAGS@
+FREETYPE_CONFIG = @FREETYPE_CONFIG@
+FREETYPE_LIBS = @FREETYPE_LIBS@
+GLIB_MKENUMS = @GLIB_MKENUMS@
+GLIB_REQ = @GLIB_REQ@
+GLIB_REQUIRED = @GLIB_REQUIRED@
+GREP = @GREP@
+GTKDOC_CHECK = @GTKDOC_CHECK@
+GTKDOC_DEPS_CFLAGS = @GTKDOC_DEPS_CFLAGS@
+GTKDOC_DEPS_LIBS = @GTKDOC_DEPS_LIBS@
+GTKDOC_MKPDF = @GTKDOC_MKPDF@
+GTKDOC_REBASE = @GTKDOC_REBASE@
+GTK_TEST_CFLAGS = @GTK_TEST_CFLAGS@
+GTK_TEST_LIBS = @GTK_TEST_LIBS@
+HTML_DIR = @HTML_DIR@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INTROSPECTION_CFLAGS = @INTROSPECTION_CFLAGS@
+INTROSPECTION_COMPILER = @INTROSPECTION_COMPILER@
+INTROSPECTION_GENERATE = @INTROSPECTION_GENERATE@
+INTROSPECTION_GIRDIR = @INTROSPECTION_GIRDIR@
+INTROSPECTION_LIBS = @INTROSPECTION_LIBS@
+INTROSPECTION_MAKEFILE = @INTROSPECTION_MAKEFILE@
+INTROSPECTION_SCANNER = @INTROSPECTION_SCANNER@
+INTROSPECTION_TYPELIBDIR = @INTROSPECTION_TYPELIBDIR@
+LCMS_CFLAGS = @LCMS_CFLAGS@
+LCMS_LIBS = @LCMS_LIBS@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBCURL_CFLAGS = @LIBCURL_CFLAGS@
+LIBCURL_LIBS = @LIBCURL_LIBS@
+LIBICONV = @LIBICONV@
+LIBJPEG_CFLAGS = @LIBJPEG_CFLAGS@
+LIBJPEG_LIBS = @LIBJPEG_LIBS@
+LIBOBJS = @LIBOBJS@
+LIBOPENJPEG_CFLAGS = @LIBOPENJPEG_CFLAGS@
+LIBOPENJPEG_LIBS = @LIBOPENJPEG_LIBS@
+LIBPNG_CFLAGS = @LIBPNG_CFLAGS@
+LIBPNG_LIBS = @LIBPNG_LIBS@
+LIBS = @LIBS@
+LIBTIFF_CFLAGS = @LIBTIFF_CFLAGS@
+LIBTIFF_CFLAGSS = @LIBTIFF_CFLAGSS@
+LIBTIFF_LIBS = @LIBTIFF_LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
+MKDIR_P = @MKDIR_P@
+MOCQT4 = @MOCQT4@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PC_REQUIRES = @PC_REQUIRES@
+PC_REQUIRES_PRIVATE = @PC_REQUIRES_PRIVATE@
+PDFTOCAIRO_CFLAGS = @PDFTOCAIRO_CFLAGS@
+PDFTOCAIRO_LIBS = @PDFTOCAIRO_LIBS@
+PKG_CONFIG = @PKG_CONFIG@
+PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
+PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
+POPPLER_DATADIR = @POPPLER_DATADIR@
+POPPLER_GLIB_CFLAGS = @POPPLER_GLIB_CFLAGS@
+POPPLER_GLIB_DISABLE_DEPRECATED = @POPPLER_GLIB_DISABLE_DEPRECATED@
+POPPLER_GLIB_DISABLE_SINGLE_INCLUDES = @POPPLER_GLIB_DISABLE_SINGLE_INCLUDES@
+POPPLER_GLIB_LIBS = @POPPLER_GLIB_LIBS@
+POPPLER_MAJOR_VERSION = @POPPLER_MAJOR_VERSION@
+POPPLER_MICRO_VERSION = @POPPLER_MICRO_VERSION@
+POPPLER_MINOR_VERSION = @POPPLER_MINOR_VERSION@
+POPPLER_QT4_CFLAGS = @POPPLER_QT4_CFLAGS@
+POPPLER_QT4_CXXFLAGS = @POPPLER_QT4_CXXFLAGS@
+POPPLER_QT4_LIBS = @POPPLER_QT4_LIBS@
+POPPLER_QT4_TEST_CFLAGS = @POPPLER_QT4_TEST_CFLAGS@
+POPPLER_QT4_TEST_LIBS = @POPPLER_QT4_TEST_LIBS@
+POPPLER_VERSION = @POPPLER_VERSION@
+PTHREAD_CC = @PTHREAD_CC@
+PTHREAD_CFLAGS = @PTHREAD_CFLAGS@
+PTHREAD_LIBS = @PTHREAD_LIBS@
+RANLIB = @RANLIB@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+TESTDATADIR = @TESTDATADIR@
+VERSION = @VERSION@
+XMKMF = @XMKMF@
+X_CFLAGS = @X_CFLAGS@
+X_EXTRA_LIBS = @X_EXTRA_LIBS@
+X_LIBS = @X_LIBS@
+X_PRE_LIBS = @X_PRE_LIBS@
+ZLIB_LIBS = @ZLIB_LIBS@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+acx_pthread_config = @acx_pthread_config@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+auto_import_flags = @auto_import_flags@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+create_shared_lib = @create_shared_lib@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+win32_libs = @win32_libs@
+INCLUDES = \
+	-I$(top_srcdir)				\
+	-I$(top_srcdir)/poppler			\
+	$(FONTCONFIG_CFLAGS)			\
+	$(POPPLER_QT4_CFLAGS)
+
+poppler_includedir = $(includedir)/poppler/qt4
+poppler_include_HEADERS = \
+	poppler-qt4.h				\
+	poppler-link.h				\
+	poppler-annotation.h			\
+	poppler-form.h				\
+	poppler-optcontent.h			\
+	poppler-export.h			\
+	poppler-media.h				\
+	poppler-page-transition.h
+
+lib_LTLIBRARIES = libpoppler-qt4.la
+libpoppler_qt4_la_SOURCES = \
+	poppler-document.cc			\
+	poppler-page.cc				\
+	poppler-fontinfo.cc			\
+	poppler-embeddedfile.cc			\
+	poppler-textbox.cc			\
+	poppler-link.cc				\
+	poppler-annotation.cc			\
+	poppler-link-extractor.cc		\
+	poppler-optcontent.cc			\
+	poppler-optcontent.h			\
+	poppler-page-transition.cc		\
+	poppler-sound.cc			\
+	poppler-form.cc				\
+	poppler-base-converter.cc		\
+	poppler-ps-converter.cc			\
+	poppler-pdf-converter.cc		\
+	poppler-qiodeviceoutstream.cc		\
+	poppler-private.cc			\
+	poppler-movie.cc			\
+	poppler-media.cc			\
+	poppler-annotation-helper.h		\
+	poppler-page-private.h			\
+	poppler-link-extractor-private.h	\
+	poppler-annotation-private.h		\
+	poppler-converter-private.h		\
+	poppler-qiodeviceoutstream-private.h	\
+	poppler-optcontent-private.h		\
+	poppler-export.h			\
+	poppler-private.h			\
+	poppler-page-transition-private.h	\
+	poppler-embeddedfile-private.h
+
+libpoppler_qt4_la_CXXFLAGS = \
+	-Dpoppler_qt4_EXPORTS
+
+libpoppler_qt4_la_LIBADD = \
+	$(top_builddir)/poppler/libpoppler.la	\
+	$(top_builddir)/poppler/libpoppler-arthur.la	\
+	$(FONTCONFIG_LIBS)				\
+	$(POPPLER_QT4_LIBS)
+
+libpoppler_qt4_la_LDFLAGS = -version-info 4:0:0 @create_shared_lib@ @auto_import_flags@
+BUILT_SOURCES = poppler-optcontent.moc
+all: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) all-am
+
+.SUFFIXES:
+.SUFFIXES: .cc .h .lo .moc .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign qt4/src/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --foreign qt4/src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	list2=; for p in $$list; do \
+	  if test -f $$p; then \
+	    list2="$$list2 $$p"; \
+	  else :; fi; \
+	done; \
+	test -z "$$list2" || { \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+	}
+
+uninstall-libLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+	for p in $$list; do \
+	  $(am__strip_dir) \
+	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+	done
+
+clean-libLTLIBRARIES:
+	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+	@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+	  dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+	  test "$$dir" != "$$p" || dir=.; \
+	  echo "rm -f \"$${dir}/so_locations\""; \
+	  rm -f "$${dir}/so_locations"; \
+	done
+libpoppler-qt4.la: $(libpoppler_qt4_la_OBJECTS) $(libpoppler_qt4_la_DEPENDENCIES) $(EXTRA_libpoppler_qt4_la_DEPENDENCIES) 
+	$(AM_V_CXXLD)$(libpoppler_qt4_la_LINK) -rpath $(libdir) $(libpoppler_qt4_la_OBJECTS) $(libpoppler_qt4_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-annotation.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-base-converter.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-document.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-embeddedfile.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-fontinfo.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-form.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-link-extractor.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-link.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-media.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-movie.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-optcontent.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-page-transition.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-page.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-pdf-converter.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-private.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-ps-converter.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-qiodeviceoutstream.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-sound.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libpoppler_qt4_la-poppler-textbox.Plo@am__quote@
+
+.cc.o:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+libpoppler_qt4_la-poppler-document.lo: poppler-document.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-document.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-document.Tpo -c -o libpoppler_qt4_la-poppler-document.lo `test -f 'poppler-document.cc' || echo '$(srcdir)/'`poppler-document.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-document.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-document.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-document.cc' object='libpoppler_qt4_la-poppler-document.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-document.lo `test -f 'poppler-document.cc' || echo '$(srcdir)/'`poppler-document.cc
+
+libpoppler_qt4_la-poppler-page.lo: poppler-page.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-page.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-page.Tpo -c -o libpoppler_qt4_la-poppler-page.lo `test -f 'poppler-page.cc' || echo '$(srcdir)/'`poppler-page.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-page.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-page.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-page.cc' object='libpoppler_qt4_la-poppler-page.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-page.lo `test -f 'poppler-page.cc' || echo '$(srcdir)/'`poppler-page.cc
+
+libpoppler_qt4_la-poppler-fontinfo.lo: poppler-fontinfo.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-fontinfo.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-fontinfo.Tpo -c -o libpoppler_qt4_la-poppler-fontinfo.lo `test -f 'poppler-fontinfo.cc' || echo '$(srcdir)/'`poppler-fontinfo.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-fontinfo.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-fontinfo.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-fontinfo.cc' object='libpoppler_qt4_la-poppler-fontinfo.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-fontinfo.lo `test -f 'poppler-fontinfo.cc' || echo '$(srcdir)/'`poppler-fontinfo.cc
+
+libpoppler_qt4_la-poppler-embeddedfile.lo: poppler-embeddedfile.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-embeddedfile.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-embeddedfile.Tpo -c -o libpoppler_qt4_la-poppler-embeddedfile.lo `test -f 'poppler-embeddedfile.cc' || echo '$(srcdir)/'`poppler-embeddedfile.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-embeddedfile.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-embeddedfile.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-embeddedfile.cc' object='libpoppler_qt4_la-poppler-embeddedfile.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-embeddedfile.lo `test -f 'poppler-embeddedfile.cc' || echo '$(srcdir)/'`poppler-embeddedfile.cc
+
+libpoppler_qt4_la-poppler-textbox.lo: poppler-textbox.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-textbox.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-textbox.Tpo -c -o libpoppler_qt4_la-poppler-textbox.lo `test -f 'poppler-textbox.cc' || echo '$(srcdir)/'`poppler-textbox.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-textbox.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-textbox.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-textbox.cc' object='libpoppler_qt4_la-poppler-textbox.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-textbox.lo `test -f 'poppler-textbox.cc' || echo '$(srcdir)/'`poppler-textbox.cc
+
+libpoppler_qt4_la-poppler-link.lo: poppler-link.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-link.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-link.Tpo -c -o libpoppler_qt4_la-poppler-link.lo `test -f 'poppler-link.cc' || echo '$(srcdir)/'`poppler-link.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-link.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-link.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-link.cc' object='libpoppler_qt4_la-poppler-link.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-link.lo `test -f 'poppler-link.cc' || echo '$(srcdir)/'`poppler-link.cc
+
+libpoppler_qt4_la-poppler-annotation.lo: poppler-annotation.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-annotation.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-annotation.Tpo -c -o libpoppler_qt4_la-poppler-annotation.lo `test -f 'poppler-annotation.cc' || echo '$(srcdir)/'`poppler-annotation.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-annotation.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-annotation.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-annotation.cc' object='libpoppler_qt4_la-poppler-annotation.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-annotation.lo `test -f 'poppler-annotation.cc' || echo '$(srcdir)/'`poppler-annotation.cc
+
+libpoppler_qt4_la-poppler-link-extractor.lo: poppler-link-extractor.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-link-extractor.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-link-extractor.Tpo -c -o libpoppler_qt4_la-poppler-link-extractor.lo `test -f 'poppler-link-extractor.cc' || echo '$(srcdir)/'`poppler-link-extractor.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-link-extractor.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-link-extractor.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-link-extractor.cc' object='libpoppler_qt4_la-poppler-link-extractor.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-link-extractor.lo `test -f 'poppler-link-extractor.cc' || echo '$(srcdir)/'`poppler-link-extractor.cc
+
+libpoppler_qt4_la-poppler-optcontent.lo: poppler-optcontent.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-optcontent.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-optcontent.Tpo -c -o libpoppler_qt4_la-poppler-optcontent.lo `test -f 'poppler-optcontent.cc' || echo '$(srcdir)/'`poppler-optcontent.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-optcontent.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-optcontent.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-optcontent.cc' object='libpoppler_qt4_la-poppler-optcontent.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-optcontent.lo `test -f 'poppler-optcontent.cc' || echo '$(srcdir)/'`poppler-optcontent.cc
+
+libpoppler_qt4_la-poppler-page-transition.lo: poppler-page-transition.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-page-transition.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-page-transition.Tpo -c -o libpoppler_qt4_la-poppler-page-transition.lo `test -f 'poppler-page-transition.cc' || echo '$(srcdir)/'`poppler-page-transition.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-page-transition.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-page-transition.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-page-transition.cc' object='libpoppler_qt4_la-poppler-page-transition.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-page-transition.lo `test -f 'poppler-page-transition.cc' || echo '$(srcdir)/'`poppler-page-transition.cc
+
+libpoppler_qt4_la-poppler-sound.lo: poppler-sound.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-sound.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-sound.Tpo -c -o libpoppler_qt4_la-poppler-sound.lo `test -f 'poppler-sound.cc' || echo '$(srcdir)/'`poppler-sound.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-sound.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-sound.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-sound.cc' object='libpoppler_qt4_la-poppler-sound.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-sound.lo `test -f 'poppler-sound.cc' || echo '$(srcdir)/'`poppler-sound.cc
+
+libpoppler_qt4_la-poppler-form.lo: poppler-form.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-form.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-form.Tpo -c -o libpoppler_qt4_la-poppler-form.lo `test -f 'poppler-form.cc' || echo '$(srcdir)/'`poppler-form.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-form.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-form.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-form.cc' object='libpoppler_qt4_la-poppler-form.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-form.lo `test -f 'poppler-form.cc' || echo '$(srcdir)/'`poppler-form.cc
+
+libpoppler_qt4_la-poppler-base-converter.lo: poppler-base-converter.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-base-converter.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-base-converter.Tpo -c -o libpoppler_qt4_la-poppler-base-converter.lo `test -f 'poppler-base-converter.cc' || echo '$(srcdir)/'`poppler-base-converter.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-base-converter.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-base-converter.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-base-converter.cc' object='libpoppler_qt4_la-poppler-base-converter.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-base-converter.lo `test -f 'poppler-base-converter.cc' || echo '$(srcdir)/'`poppler-base-converter.cc
+
+libpoppler_qt4_la-poppler-ps-converter.lo: poppler-ps-converter.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-ps-converter.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-ps-converter.Tpo -c -o libpoppler_qt4_la-poppler-ps-converter.lo `test -f 'poppler-ps-converter.cc' || echo '$(srcdir)/'`poppler-ps-converter.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-ps-converter.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-ps-converter.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-ps-converter.cc' object='libpoppler_qt4_la-poppler-ps-converter.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-ps-converter.lo `test -f 'poppler-ps-converter.cc' || echo '$(srcdir)/'`poppler-ps-converter.cc
+
+libpoppler_qt4_la-poppler-pdf-converter.lo: poppler-pdf-converter.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-pdf-converter.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-pdf-converter.Tpo -c -o libpoppler_qt4_la-poppler-pdf-converter.lo `test -f 'poppler-pdf-converter.cc' || echo '$(srcdir)/'`poppler-pdf-converter.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-pdf-converter.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-pdf-converter.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-pdf-converter.cc' object='libpoppler_qt4_la-poppler-pdf-converter.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-pdf-converter.lo `test -f 'poppler-pdf-converter.cc' || echo '$(srcdir)/'`poppler-pdf-converter.cc
+
+libpoppler_qt4_la-poppler-qiodeviceoutstream.lo: poppler-qiodeviceoutstream.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-qiodeviceoutstream.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-qiodeviceoutstream.Tpo -c -o libpoppler_qt4_la-poppler-qiodeviceoutstream.lo `test -f 'poppler-qiodeviceoutstream.cc' || echo '$(srcdir)/'`poppler-qiodeviceoutstream.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-qiodeviceoutstream.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-qiodeviceoutstream.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-qiodeviceoutstream.cc' object='libpoppler_qt4_la-poppler-qiodeviceoutstream.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-qiodeviceoutstream.lo `test -f 'poppler-qiodeviceoutstream.cc' || echo '$(srcdir)/'`poppler-qiodeviceoutstream.cc
+
+libpoppler_qt4_la-poppler-private.lo: poppler-private.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-private.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-private.Tpo -c -o libpoppler_qt4_la-poppler-private.lo `test -f 'poppler-private.cc' || echo '$(srcdir)/'`poppler-private.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-private.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-private.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-private.cc' object='libpoppler_qt4_la-poppler-private.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-private.lo `test -f 'poppler-private.cc' || echo '$(srcdir)/'`poppler-private.cc
+
+libpoppler_qt4_la-poppler-movie.lo: poppler-movie.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-movie.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-movie.Tpo -c -o libpoppler_qt4_la-poppler-movie.lo `test -f 'poppler-movie.cc' || echo '$(srcdir)/'`poppler-movie.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-movie.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-movie.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-movie.cc' object='libpoppler_qt4_la-poppler-movie.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-movie.lo `test -f 'poppler-movie.cc' || echo '$(srcdir)/'`poppler-movie.cc
+
+libpoppler_qt4_la-poppler-media.lo: poppler-media.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -MT libpoppler_qt4_la-poppler-media.lo -MD -MP -MF $(DEPDIR)/libpoppler_qt4_la-poppler-media.Tpo -c -o libpoppler_qt4_la-poppler-media.lo `test -f 'poppler-media.cc' || echo '$(srcdir)/'`poppler-media.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/libpoppler_qt4_la-poppler-media.Tpo $(DEPDIR)/libpoppler_qt4_la-poppler-media.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='poppler-media.cc' object='libpoppler_qt4_la-poppler-media.lo' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libpoppler_qt4_la_CXXFLAGS) $(CXXFLAGS) -c -o libpoppler_qt4_la-poppler-media.lo `test -f 'poppler-media.cc' || echo '$(srcdir)/'`poppler-media.cc
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+install-poppler_includeHEADERS: $(poppler_include_HEADERS)
+	@$(NORMAL_INSTALL)
+	@list='$(poppler_include_HEADERS)'; test -n "$(poppler_includedir)" || list=; \
+	if test -n "$$list"; then \
+	  echo " $(MKDIR_P) '$(DESTDIR)$(poppler_includedir)'"; \
+	  $(MKDIR_P) "$(DESTDIR)$(poppler_includedir)" || exit 1; \
+	fi; \
+	for p in $$list; do \
+	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+	  echo "$$d$$p"; \
+	done | $(am__base_list) | \
+	while read files; do \
+	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(poppler_includedir)'"; \
+	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(poppler_includedir)" || exit $$?; \
+	done
+
+uninstall-poppler_includeHEADERS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(poppler_include_HEADERS)'; test -n "$(poppler_includedir)" || list=; \
+	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+	dir='$(DESTDIR)$(poppler_includedir)'; $(am__uninstall_files_from_dir)
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) check-am
+all-am: Makefile $(LTLIBRARIES) $(HEADERS)
+installdirs:
+	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(poppler_includedir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	if test -z '$(STRIP)'; then \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	      install; \
+	else \
+	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
+	fi
+mostlyclean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+	mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-poppler_includeHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-libLTLIBRARIES \
+	uninstall-poppler_includeHEADERS
+
+.MAKE: all check install install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+	clean-libLTLIBRARIES clean-libtool ctags distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am \
+	install-libLTLIBRARIES install-man install-pdf install-pdf-am \
+	install-poppler_includeHEADERS install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
+	pdf pdf-am ps ps-am tags uninstall uninstall-am \
+	uninstall-libLTLIBRARIES uninstall-poppler_includeHEADERS
+
+
+SUFFIXES: .moc
+
+# This rule lets GNU make create any *.moc from the equivalent *.h
+.h.moc:
+	$(AM_V_GEN) $(MOCQT4) -i $< -o $@
+
+clean-generic:
+	rm -f *.moc
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:

=== added file '.pc/qt4-visibility.diff/qt4/src/poppler-export.h'
--- .pc/qt4-visibility.diff/qt4/src/poppler-export.h	1970-01-01 00:00:00 +0000
+++ .pc/qt4-visibility.diff/qt4/src/poppler-export.h	2012-11-16 16:39:27 +0000
@@ -0,0 +1,17 @@
+/*
+* This file is used to set the poppler_qt4_EXPORT macros right.
+* This is needed for setting the visibility on windows, it will have no effect on other platforms.
+*/
+#if defined(_WIN32)
+# define LIB_EXPORT __declspec(dllexport)
+# define LIB_IMPORT __declspec(dllimport)
+#else
+# define LIB_EXPORT
+# define LIB_IMPORT
+#endif
+
+#ifdef poppler_qt4_EXPORTS
+# define POPPLER_QT4_EXPORT LIB_EXPORT
+#else
+# define POPPLER_QT4_EXPORT LIB_IMPORT
+#endif

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-06-07 17:13:58 +0000
+++ CMakeLists.txt	2012-11-16 16:39:27 +0000
@@ -16,7 +16,7 @@
 
 set(POPPLER_MAJOR_VERSION "0")
 set(POPPLER_MINOR_VERSION "20")
-set(POPPLER_MICRO_VERSION "0")
+set(POPPLER_MICRO_VERSION "4")
 set(POPPLER_VERSION "${POPPLER_MAJOR_VERSION}.${POPPLER_MINOR_VERSION}.${POPPLER_MICRO_VERSION}")
 
 # command line switches
@@ -386,7 +386,7 @@
 else(MSVC)
 add_library(poppler SHARED ${poppler_SRCS})
 endif(MSVC)
-set_target_properties(poppler PROPERTIES VERSION 25.0.0 SOVERSION 25)
+set_target_properties(poppler PROPERTIES VERSION 28.0.0 SOVERSION 28)
 target_link_libraries(poppler ${poppler_LIBS})
 target_link_libraries(poppler LINK_INTERFACE_LIBRARIES "")
 install(TARGETS poppler RUNTIME DESTINATION bin LIBRARY DESTINATION lib${LIB_SUFFIX} ARCHIVE DESTINATION lib${LIB_SUFFIX})

=== modified file 'ChangeLog'
--- ChangeLog	2012-06-07 17:13:58 +0000
+++ ChangeLog	2012-11-16 16:39:27 +0000
@@ -1,3 +1,687 @@
+commit 5fd691dc58aac817bca81c87c4820afcf53989d1
+Author: Albert Astals Cid <[e-mail]>
+Date:   Mon Sep 10 19:29:01 2012 +0200
+
+    0.20.40.20.40.20.40.20.4
+
+ CMakeLists.txt      |    4 ++--
+ NEWS                |   13 +++++++++++++
+ configure.ac        |    2 +-
+ cpp/Doxyfile        |    2 +-
+ poppler/Makefile.am |    2 +-
+ qt4/src/Doxyfile    |    2 +-
+ 6 files changed, 19 insertions(+), 6 deletions(-)
+
+commit b3e86dbdba82956f125e37f69176072e2d0127f2
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 23:35:45 2012 +0200
+
+    Try to find another rootNum if actual rootNum doesn't point to a dict
+
+    Bug #14303
+
+ poppler/XRef.cc |   14 ++++++++++++--
+ poppler/XRef.h  |    4 ++--
+ 2 files changed, 14 insertions(+), 4 deletions(-)
+
+commit 558a7d9b046bbbe185dea263b48a3cb2664378fc
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 23:25:47 2012 +0200
+
+    Fix invalid memory access in solves 1066.pdf.asan.38.75
+
+ splash/SplashClip.cc         |   23 +++++++++++++++++++++++
+ splash/SplashXPathScanner.cc |    3 +++
+ 2 files changed, 26 insertions(+)
+
+commit d0df8e54512f584ca2b3edbae1c19e167948e5c3
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 23:21:38 2012 +0200
+
+    Fix invalid memory access in 1106.pdf.asan.30.120.patch
+
+ poppler/Function.cc |    5 +++++
+ 1 file changed, 5 insertions(+)
+
+commit 86b89864396a1dcf027e5793e6ac75411977bcf9
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 23:08:49 2012 +0200
+
+    Fix crash in 1255.pdf.SIGSEGV.56f.285
+
+ poppler/XRef.cc |    6 ++++++
+ 1 file changed, 6 insertions(+)
+
+commit 96931732f343d2bbda9af9488b485da031866c3b
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 22:47:57 2012 +0200
+
+    Fix invalid memory access in 61.pdf.asan.13.95
+
+ fofi/FoFiType1C.cc |   25 +++++++++++++++++--------
+ fofi/FoFiType1C.h  |    2 ++
+ 2 files changed, 19 insertions(+), 8 deletions(-)
+
+commit 26917d69c4da6a110db02b120133c36579fbb17c
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Sep 9 22:23:36 2012 +0200
+
+    Add unlikely
+
+ poppler/Gfx.cc |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit e6a3c797c01aa343f640f2e6f45de5bf379aa8ad
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 22:22:59 2012 +0200
+
+    Fix wrong memory access in 68.pdf.asan.7.1030
+
+ poppler/Gfx.cc |    4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit 48fe18cf277cd2a4e665c74b3a594482f762f4b6
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Sep 9 22:09:44 2012 +0200
+
+    Fix memory leak
+
+ poppler/Gfx.cc |    1 +
+ 1 file changed, 1 insertion(+)
+
+commit b87aafc0cdb36c3555053f2684c45f1a9d7b2f94
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Sep 9 21:42:48 2012 +0200
+
+    Add unlikelys to the ifs
+
+ poppler/DCTStream.cc   |    4 ++--
+ poppler/JBIG2Stream.cc |    2 +-
+ 2 files changed, 3 insertions(+), 3 deletions(-)
+
+commit a019eef2f8ca53addd7ccab7f9c47657f4e52286
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 21:41:09 2012 +0200
+
+    Fix crash in 1162.pdf.SIGSEGV.28e.182
+
+ poppler/DCTStream.cc |    4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit ad7c6ac88f2315c9ce003308d1b4988592d4434b
+Author: William Bader <[e-mail]>
+Date:   Sun Sep 9 21:31:58 2012 +0200
+
+    Fix crash in 1028.pdf.SIGSEGV.ae6.33
+
+ poppler/JBIG2Stream.cc |    8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+commit b861af714daee4125e54b250dddf82106f5a8ce8
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Sep 9 21:15:06 2012 +0200
+
+    Fix memory leak
+
+ poppler/Form.cc |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit a4f59113574a8d7460c6ce5000cb09d20fe52b74
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Sep 9 12:49:43 2012 +0200
+
+    Fix memory leak
+
+ poppler/Annot.cc |    3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit 28240046f8fe37ca96f9a80cb1ea3a59af9c66f3
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Sep 9 12:48:26 2012 +0200
+
+    Fix crash in 589.pdf.SIGSEGV.8b1.929
+
+ poppler/Annot.cc |    8 ++++++++
+ 1 file changed, 8 insertions(+)
+
+commit ccd3db5a7723ddb692f6dc85ed9d0f5e3dde189f
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sat Sep 8 18:10:14 2012 +0200
+
+    Only complain when the malloc really failed
+
+ poppler/JBIG2Stream.cc |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 6356c0bbae47db291a3585d31c7727bc3f8d97a4
+Author: Albert Astals Cid <[e-mail]>
+Date:   Thu Aug 30 00:57:51 2012 +0200
+
+    qt4: unbreak spacing
+
+ qt4/src/poppler-embeddedfile.cc |    6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+commit 46948868dee6d4e68b658c68d7df482590e34da3
+Author: Albert Astals Cid <[e-mail]>
+Date:   Thu Aug 30 00:43:45 2012 +0200
+
+    Accept FileSpec as Dict too and not only as Ref
+
+    File to try in KDE bug #306008
+
+ poppler/Catalog.cc |    4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit debc8fb497bc22c0f9f34d785852981a87475c30
+Author: Albert Astals Cid <[e-mail]>
+Date:   Thu Aug 30 00:35:40 2012 +0200
+
+    Take into account the embFile returned by the core may be NULL
+
+ qt4/src/poppler-embeddedfile-private.h |    4 +++-
+ qt4/src/poppler-embeddedfile.cc        |   19 ++++++++++++-------
+ 2 files changed, 15 insertions(+), 8 deletions(-)
+
+commit 3ca67a59fc15782abb1e479eb2b8916de5b1b6ed
+Author: Albert Astals Cid <[e-mail]>
+Date:   Thu Aug 30 00:34:06 2012 +0200
+
+    Return NULL EmbFile if the FileSpec is not ok
+
+    Otherwise we might end up asserting
+
+ poppler/FileSpec.cc |    4 ++++
+ 1 file changed, 4 insertions(+)
+
+commit 686ec0cc92e25f74eaa9e09a328724cbdf939bca
+Author: Albert Astals Cid <[e-mail]>
+Date:   Wed Aug 15 20:02:05 2012 +0200
+
+    Remove declared but not implemented function
+
+ poppler/XRef.h |    1 -
+ 1 file changed, 1 deletion(-)
+
+commit e83568065f77ba722b147b3b10faed1ff66f22dc
+Author: Pino Toscano <[e-mail]>
+Date:   Sat Aug 11 01:38:08 2012 +0200
+
+    remove extra execution permissions
+
+    (cherry picked from commit 9a5a19ee2f9cd536c3527b30c0256ca9dce3638c)
+
+ 0 files changed
+
+commit 1b2903c104012fdd3c982d57898910945dff9a15
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sat Aug 11 00:05:10 2012 +0200
+
+    0.20.3
+
+ CMakeLists.txt      |    4 ++--
+ NEWS                |   16 ++++++++++++++++
+ configure.ac        |    2 +-
+ cpp/Doxyfile        |    2 +-
+ poppler/Makefile.am |    2 +-
+ qt4/src/Doxyfile    |    2 +-
+ 6 files changed, 22 insertions(+), 6 deletions(-)
+
+commit 40e7b744d32152ab4c6201b8bda7fb7caf6bfd4e
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Aug 5 15:07:16 2012 +0200
+
+    If NULL, NULL fails as password try EMPTY, EMPTY before failing
+
+    Reviewed by Jose Aliste
+    Bug #3498
+
+ poppler/SecurityHandler.cc |    7 ++++++-
+ 1 file changed, 6 insertions(+), 1 deletion(-)
+
+commit 3ca2bc0d3abdf92741b7921ea402c9de09e531f6
+Author: Markus Trippelsdorf <[e-mail]>
+Date:   Fri Aug 3 00:48:12 2012 +0200
+
+    Fix segfault when scaleImage returns NULL
+
+    Bug 52488
+
+ splash/Splash.cc |    7 +++++++
+ 1 file changed, 7 insertions(+)
+
+commit 768cf5877f48f8cee80fe96e2ee52f42f230dfdf
+Author: Thomas Freitag <[e-mail]>
+Date:   Thu Aug 2 00:22:19 2012 +0200
+
+    PSOutputDev: Fix Bitmaps in level2sep or level3sep
+
+    Bug #52384
+
+ poppler/PSOutputDev.cc |    4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 315447843a368556a8536bc30e579c9bf338682e
+Author: Thomas Freitag <[e-mail]>
+Date:   Wed Aug 1 22:56:49 2012 +0200
+
+    Splash: Blend mode enhancements for CMYK
+
+ poppler/SplashOutputDev.cc |   76
+ +++++++++++++++++++++++++++++++-------------
+ splash/Splash.cc           |   22 -------------
+ 2 files changed, 54 insertions(+), 44 deletions(-)
+
+commit c0c88b3707fc7337e814ae4252d80002641a19ee
+Author: Albert Astals Cid <[e-mail]>
+Date:   Tue Jul 31 23:32:19 2012 +0200
+
+    Replace c++ style includes with c style ones
+
+    Fixes build in Solaris 10
+    Bug #52426
+
+ goo/gstrtod.cc |   10 +++++-----
+ 1 file changed, 5 insertions(+), 5 deletions(-)
+
+commit dcbc923bd3592a81876f84005fbaddcea18641cc
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Jul 22 18:40:46 2012 +0200
+
+    Make sure xScale and yScale are always initialized
+
+    Bug #52215
+
+ poppler/PSOutputDev.cc |    5 +----
+ 1 file changed, 1 insertion(+), 4 deletions(-)
+
+commit ef7c2418e12d3e6a79f1d89a0051b005fadbc344
+Author: Thomas Freitag <[e-mail]>
+Date:   Sat Jul 21 00:01:49 2012 +0200
+
+    Fix conversion to ps when having multiple strips
+
+    Bug 51982
+
+ poppler/PSOutputDev.cc |    4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+commit 349b21acc249c130fb053bc4a0c75019f75bd35b
+Author: Torsten Kasch <[e-mail]>
+Date:   Thu Jul 19 00:18:14 2012 +0200
+
+    Unify poppler-config.h includes in core "installed" headers
+
+    Bug 52193
+
+ goo/FixedPoint.h      |    2 +-
+ goo/GooTimer.h        |    2 +-
+ goo/JpegWriter.h      |    2 +-
+ goo/PNGWriter.h       |    2 +-
+ goo/TiffWriter.h      |    2 +-
+ goo/gfile.h           |    2 +-
+ goo/gmem.h            |    2 +-
+ splash/SplashFTFont.h |    2 +-
+ splash/SplashMath.h   |    2 +-
+ 9 files changed, 9 insertions(+), 9 deletions(-)
+
+commit 15c6ae699f083ea6c9716c1098ae9833a56eeb3e
+Author: Torsten Kasch <[e-mail]>
+Date:   Thu Jul 19 00:06:45 2012 +0200
+
+    autoconf: Do not assume the shell is bash compatible
+
+    Bug 52197
+
+ configure.ac |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit f5311da76ec7cd7c1e6cdfc4e18df6dd56e8398b
+Author: Albert Astals Cid <[e-mail]>
+Date:   Thu Jul 19 00:01:49 2012 +0200
+
+    pdfseparate: Return 0 on success
+
+ utils/pdfseparate.cc |    6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+commit 51f22ca0badfc41c19cba66cabd63184244f81c7
+Author: Thomas Freitag <[e-mail]>
+Date:   Mon Jul 16 23:32:23 2012 +0200
+
+    PSOutputDev: Fix DeviceN images with alternate Lab colorspace in
+    level 3 PostScript
+
+    Bug #51822
+
+ poppler/PSOutputDev.cc |   54
+ +++++++++++++++++++++++++++++++++++++++++-------
+ poppler/PSOutputDev.h  |    2 +-
+ 2 files changed, 48 insertions(+), 8 deletions(-)
+
+commit 950d5f3dec4bff5d3c523d55689d7b70215dc110
+Author: Thomas Freitag <[e-mail]>
+Date:   Fri Jul 13 00:56:48 2012 +0200
+
+    Fix Splash::arbitraryTransformImage causes bogus memory allocation
+    size
+
+    Bug #49523
+
+ poppler/SplashOutputDev.cc |    2 +-
+ splash/Splash.cc           |   79
+ +++++++++++++++++++++++++-------------------
+ splash/Splash.h            |    4 +--
+ 3 files changed, 48 insertions(+), 37 deletions(-)
+
+commit e09be3bc6ba1290fd31bde0c3d19c4ffcbadbf00
+Author: Albert Astals Cid <[e-mail]>
+Date:   Tue Jul 10 23:06:53 2012 +0200
+
+    0.20.2
+
+ CMakeLists.txt   |    2 +-
+ NEWS             |   11 +++++++++++
+ configure.ac     |    2 +-
+ cpp/Doxyfile     |    2 +-
+ qt4/src/Doxyfile |    2 +-
+ 5 files changed, 15 insertions(+), 4 deletions(-)
+
+commit e15fe0e1e6accf779caeb1179a8d62161c0aa650
+Author: Thomas Freitag <[e-mail]>
+Date:   Thu Jul 5 17:44:02 2012 +0200
+
+    Fix handling of DeviceN images in level 3 PostScript
+
+    bug #51548
+
+ poppler/PSOutputDev.cc |   14 --------------
+ 1 file changed, 14 deletions(-)
+
+commit 02c4e6bf4cc0f5535946fe31815081a40b1de986
+Author: Albert Astals Cid <[e-mail]>
+Date:   Fri Jun 29 01:56:55 2012 +0200
+
+    PSOutputDev: Correct %%DocumentCustomColors
+
+    Bug 51479
+
+ poppler/PSOutputDev.cc |   20 ++++++++++++++++++++
+ 1 file changed, 20 insertions(+)
+
+commit f7990386d268a444c297958e9c50ed27a0825a00
+Author: Albert Astals Cid <[e-mail]>
+Date:   Thu Jun 28 00:18:07 2012 +0200
+
+    Add some security checks to JPXStream decoding
+
+    Fixes crash in broken/fuzzed pdf sent by Mateusz "j00ru" Jurczyk
+    and Gynvael Coldwind
+
+ poppler/JPXStream.cc |   14 ++++++++++++--
+ 1 file changed, 12 insertions(+), 2 deletions(-)
+
+commit c5c6eed1623506e1206e89cee0b7c887d815ba62
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Jun 24 23:43:03 2012 +0200
+
+    Change SplashBitmap gmallocn to gmallocn_checkoverflow
+
+    Fixes abort in KDE bug #302372
+
+ splash/Splash.cc       |   37 +++++++++++++++++++++++--------------
+ splash/SplashBitmap.cc |   18 +++++++++++-------
+ 2 files changed, 34 insertions(+), 21 deletions(-)
+
+commit c87738ee234aafc6eda5a263ad789205037020e1
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Jun 24 20:20:38 2012 +0200
+
+    copy resources content defined in the pages dict
+
+    Fixes bug #51369
+
+ poppler/PDFDoc.cc |   16 ++++++++++++++--
+ 1 file changed, 14 insertions(+), 2 deletions(-)
+
+commit 6cdf879e389f05abba30b3fad8083b7fff23056e
+Author: Fabio D'Urso <[e-mail]>
+Date:   Sun Jun 24 11:48:04 2012 +0200
+
+    qt4: Do not hang on malformed /Annots objects
+
+    Don't recurse infinitely if the /Annots object contains annotation
+    dictionaries (according to specs, /Annots must contain *references*
+    to annotation dictionaries).
+
+    Fixes bug #51361
+
+ qt4/src/poppler-annotation.cc |    5 +++++
+ 1 file changed, 5 insertions(+)
+
+commit 3575becd60585324bcefc0631b1bac47c1db3c5c
+Author: Mark Brand <[e-mail]>
+Date:   Thu Jun 14 20:31:26 2012 +0200
+
+    fix typo to compile in Windows
+
+ poppler/GlobalParamsWin.cc |    3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit 06618065c8a97a5bec125560546b98edfc1210f3
+Author: Albert Astals Cid <[e-mail]>
+Date:   Mon Jun 11 15:17:59 2012 +0200
+
+    Add some security checks to JBIG2Stream decoding
+
+    Fixes crash in broken/fuzzed pdf sent by Mateusz "j00ru" Jurczyk
+    and Gynvael Coldwind
+
+ poppler/JBIG2Stream.cc |   58
+ ++++++++++++++++++++++++++++++++++++------------
+ 1 file changed, 44 insertions(+), 14 deletions(-)
+
+commit e3fe88df3646a80945210ba426eb4681a98b55e9
+Author: Hib Eris <[e-mail]>
+Date:   Sun Jun 10 19:44:18 2012 +0200
+
+    Check value of first page in linearization table
+
+    Fixes crash in broken/fuzzed pdf sent by Mateusz "j00ru" Jurczyk
+    and Gynvael Coldwind
+
+ poppler/Linearization.cc |    4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 1240eee8c0d0d01113443e0fda87721775a76da9
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Jun 10 20:42:55 2012 +0200
+
+    0.20.1
+
+ CMakeLists.txt      |    4 ++--
+ NEWS                |   25 +++++++++++++++++++++++++
+ configure.ac        |    2 +-
+ cpp/Doxyfile        |    2 +-
+ poppler/Makefile.am |    2 +-
+ qt4/src/Doxyfile    |    2 +-
+ 6 files changed, 31 insertions(+), 6 deletions(-)
+
+commit c783037619e2b4c101e8ecd7e61c94ee077b4be2
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Jun 10 20:15:01 2012 +0200
+
+    Update copyrights
+
+ poppler/GlobalParamsWin.cc |    1 +
+ 1 file changed, 1 insertion(+)
+
+commit f3f9d8f28a97338da92c842d5668b0ef3495ef13
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun Jun 10 19:09:17 2012 +0200
+
+    Do use NULL function
+
+    Fixes crash in broken/fuzzed pdf sent by Mateusz "j00ru" Jurczyk
+    and Gynvael Coldwind
+
+ poppler/Gfx.cc |    5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+commit 92ef16e3699da949c80716c3fd4b438fe79c134d
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun Jun 10 16:58:54 2012 +0200
+
+    use setoverprintmode only if rip knows it
+
+ poppler/PSOutputDev.cc |    6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+commit 99aa734ae2d3ba51f840d4c8ef450488fb702a31
+Author: Fabio D'Urso <[e-mail]>
+Date:   Thu May 24 23:17:27 2012 +0200
+
+    qt4: Keep page rotation into account when normalizing annotation
+    coords
+
+    If the page is rotated by 90 or 270 degrees, width and height need
+    to be swapped
+
+ qt4/src/poppler-annotation.cc |   16 ++++++++++++++--
+ 1 file changed, 14 insertions(+), 2 deletions(-)
+
+commit bde31ce7b223abc86d25e06f3d73668b792c70df
+Author: Fabio D'Urso <[e-mail]>
+Date:   Sat Jun 9 01:31:29 2012 +0200
+
+    Fix saving to xml
+
+    The default icon is Note not comment
+
+ qt4/src/poppler-annotation.cc |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 9904b8f10abf068a7816bd90976ccbb320387645
+Author: Adrian Johnson <[e-mail]>
+Date:   Thu May 24 18:24:48 2012 +0930
+
+    glib docs: fix typo
+
+ glib/poppler-document.cc |    4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+commit 028f580056f99719cfb8af7bbe8184ceac02cb16
+Author: Adrian Johnson <[e-mail]>
+Date:   Sun May 13 21:36:36 2012 +0930
+
+    add sustitute font name to GlobalParamsWin32 to fix compilation
+
+ poppler/GlobalParamsWin.cc |    5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+commit 1916d000a86336213ffd6e9bd44ce873e8955895
+Author: Adrian Johnson <[e-mail]>
+Date:   Sat May 12 16:31:38 2012 +0930
+
+    Include substitute font name in system font cache
+
+    Bug 49826
+
+ poppler/FontInfo.cc     |    1 +
+ poppler/GlobalParams.cc |   58
+ ++++++++++++++++++++++++++---------------------
+ 2 files changed, 33 insertions(+), 26 deletions(-)
+
+commit 1c6e84555572a6bf3a2e3fbe9a54b40f11c122ad
+Author: Fabio D'Urso <[e-mail]>
+Date:   Fri May 18 16:22:46 2012 +0200
+
+    qt4: Make TextAnnotation ctor public
+
+ qt4/src/poppler-annotation.h |    2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+commit 8e504bf2543621973fdaddbd29055ce435540146
+Author: Ville Skyttä <[e-mail]>
+Date:   Wed May 16 23:49:01 2012 +0300
+
+    pdfseparate.1: Syntax fixes.
+
+ utils/pdfseparate.1 |    6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+commit 9f7d919e68a26bb7dd809986d8394fe20b750bd0
+Author: Anthony Wesley <[e-mail]>
+Date:   Thu May 17 19:54:47 2012 +0200
+
+    Fix logic on SplashBitmap::writeImgFile
+
+ splash/SplashBitmap.cc |    3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+commit 7e7997e12faccf4c0513811b324a2fd0fa960a96
+Author: Igor Slepchin <[e-mail]>
+Date:   Tue May 15 23:16:27 2012 +0200
+
+    Determine if font is bold or italic based on FontDescriptor.
+
+    Bug #49758
+
+ utils/HtmlFonts.cc     |   24 ++++++++++++++++++------
+ utils/HtmlFonts.h      |    3 ++-
+ utils/HtmlOutputDev.cc |    4 +---
+ 3 files changed, 21 insertions(+), 10 deletions(-)
+
+commit 329bb1e2b4f4b58832847bcf805d19ac0fd5ef02
+Author: Carlos Garcia Campos <[e-mail]>
+Date:   Sun May 13 19:45:55 2012 +0200
+
+    glib: Make sure password is always converted to latin1
+
+    Remove the utf8 validation since glib API is supposed to always
+    receive
+    utf8 strings.
+
+ glib/poppler-document.cc |   38 +++++++++++++++++++-------------------
+ 1 file changed, 19 insertions(+), 19 deletions(-)
+
+commit 7714b4e319c48ee915061a172208245ae7c4141b
+Author: Carlos Garcia Campos <[e-mail]>
+Date:   Sun May 13 19:30:17 2012 +0200
+
+    glib: Fix memory leak when document fails to load
+
+ glib/poppler-document.cc |    3 +--
+ 1 file changed, 1 insertion(+), 2 deletions(-)
+
+commit 13d2aa303eb1fd900f1045efec14af8002477b02
+Author: Thomas Freitag <[e-mail]>
+Date:   Sun May 13 17:25:15 2012 +0200
+
+    remove unnecesary transparency group handling in splash
+
+    Bug #13487
+
+ poppler/Gfx.cc             |   64
+ +++++++++++++++++++++++++++++++++++++++++++-
+ poppler/Gfx.h              |    4 ++-
+ poppler/GfxState.cc        |    4 ++-
+ poppler/OutputDev.h        |    1 +
+ poppler/SplashOutputDev.cc |   11 ++++++++
+ poppler/SplashOutputDev.h  |    1 +
+ 6 files changed, 82 insertions(+), 3 deletions(-)
+
+commit a76867003a7bff5ab03016156c75b4c928788d50
+Author: Albert Astals Cid <[e-mail]>
+Date:   Sun May 13 13:10:40 2012 +0200
+
+    Distribute cmake/modules/FindLCMS2.cmake
+
+    Bug #49818
+
+ Makefile.am |    1 +
+ 1 file changed, 1 insertion(+)
+
 commit 4114c928fa2560937e02319f57937f1c267a9817
 Author: Albert Astals Cid <[e-mail]>
 Date:   Thu May 10 21:09:14 2012 +0200

=== modified file 'Makefile.am'
--- Makefile.am	2012-06-07 17:13:58 +0000
+++ Makefile.am	2012-11-16 16:39:27 +0000
@@ -76,6 +76,7 @@
 	cmake/modules/FindGTK.cmake				\
 	cmake/modules/FindIconv.cmake				\
 	cmake/modules/FindLCMS.cmake				\