Attachment 45937 Details for Bug 28053 – glib/poppler-page.cc

[patch] glib/poppler-page.cc

poppler-page.cc (text/plain), 52.02 KB, created by Sebastian Kums on 2011-04-22 03:09:55 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Sebastian Kums

Created: 2011-04-22 03:09:55 UTC

Size: 52.02 KB

patch

obsolete

>/* poppler-page.cc: glib wrapper for poppler
> * Copyright (C) 2005, Red Hat, Inc.
> *
> * This program is free software; you can redistribute it and/or modify
> * it under the terms of the GNU General Public License as published by
> * the Free Software Foundation; either version 2, or (at your option)
> * any later version.
> *
> * This program is distributed in the hope that it will be useful,
> * but WITHOUT ANY WARRANTY; without even the implied warranty of
> * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> * GNU General Public License for more details.
> *
> * You should have received a copy of the GNU General Public License
> * along with this program; if not, write to the Free Software
> * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
> */
>
>#include "config.h"
>#include <math.h>
>
>#include <goo/GooList.h>
>#include <splash/SplashBitmap.h>
>#include <GlobalParams.h>
>#include <PDFDoc.h>
>#include <Outline.h>
>#include <ErrorCodes.h>
>#include <UnicodeMap.h>
>#include <GfxState.h>
>#include <PageTransition.h>
>#include <UnicodeTypeTable.h>
>
>#include "poppler.h"
>#include "poppler-private.h"
>
>enum
>{
>  PROP_0,
>  PROP_LABEL
>};
>
>typedef struct _PopplerPageClass PopplerPageClass;
>struct _PopplerPageClass
>{
>  GObjectClass parent_class;
>};
>
>G_DEFINE_TYPE (PopplerPage, poppler_page, G_TYPE_OBJECT)
>
>PopplerPage *
>_poppler_page_new (PopplerDocument *document, Page *page, int index)
>{
>  PopplerPage *poppler_page;
>
>  g_return_val_if_fail (POPPLER_IS_DOCUMENT (document), NULL);
>
>  poppler_page = (PopplerPage *) g_object_new (POPPLER_TYPE_PAGE, NULL, NULL);
>  poppler_page->document = (PopplerDocument *) g_object_ref (document);
>  poppler_page->page = page;
>  poppler_page->index = index;
>
>  return poppler_page;
>}
>
>static void
>poppler_page_finalize (GObject *object)
>{
>  PopplerPage *page = POPPLER_PAGE (object);
>
>  g_object_unref (page->document);
>  page->document = NULL;
>
>  if (page->annots != NULL)
>    delete page->annots;
>#if defined (HAVE_CAIRO)
>  if (page->text != NULL) 
>    page->text->decRefCnt();
>#else
>  if (page->gfx != NULL)
>    delete page->gfx;  
>  if (page->text_dev != NULL)
>    delete page->text_dev;
>#endif
>  /* page->page is owned by the document */
>}
>
>/**
> * poppler_page_get_size:
> * @page: A #PopplerPage
> * @width: return location for the width of @page
> * @height: return location for the height of @page
> * 
> * Gets the size of @page at the current scale and rotation.
> **/
>void
>poppler_page_get_size (PopplerPage *page,
>		       double      *width,
>		       double      *height)
>{
>  double page_width, page_height;
>  int rotate;
>
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>
>  rotate = page->page->getRotate ();
>  if (rotate == 90 || rotate == 270) {
>    page_height = page->page->getCropWidth ();
>    page_width = page->page->getCropHeight ();
>  } else {
>    page_width = page->page->getCropWidth ();
>    page_height = page->page->getCropHeight ();
>  }
>
>  if (width != NULL)
>    *width = page_width;
>  if (height != NULL)
>    *height = page_height;
>}
>
>/**
> * poppler_page_get_index:
> * @page: a #PopplerPage
> * 
> * Returns the index of @page
> * 
> * Return value: index value of @page
> **/
>int
>poppler_page_get_index (PopplerPage *page)
>{
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), 0);
>
>  return page->index;
>}
>
>/**
> * poppler_page_get_duration:
> * @page: a #PopplerPage
> *
> * Returns the duration of @page
> *
> * Return value: duration in seconds of @page or -1.
> **/
>double
>poppler_page_get_duration (PopplerPage *page)
>{
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), -1);
>
>  return page->page->getDuration ();
>}
>
>/**
> * poppler_page_get_transition:
> * @page: a #PopplerPage
> *
> * Returns the transition effect of @page
> *
> * Return value: a #PopplerPageTransition or NULL.
> **/
>PopplerPageTransition *
>poppler_page_get_transition (PopplerPage *page)
>{
>  PageTransition *trans;
>  PopplerPageTransition *transition;
>  Object obj;
>  
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), NULL);
>
>  trans = new PageTransition (page->page->getTrans (&obj));
>  obj.free ();
>
>  if (!trans->isOk ()) {
>    delete trans;
>    return NULL;
>  }
>
>  transition = poppler_page_transition_new ();
>
>  switch (trans->getType ())
>    {
>      case transitionReplace:
>        transition->type = POPPLER_PAGE_TRANSITION_REPLACE;
>	break;
>      case transitionSplit:
>	transition->type = POPPLER_PAGE_TRANSITION_SPLIT;
>	break;
>      case transitionBlinds:
>        transition->type = POPPLER_PAGE_TRANSITION_BLINDS;
>	break;
>      case transitionBox:
>        transition->type = POPPLER_PAGE_TRANSITION_BOX;
>	break;
>      case transitionWipe:
>        transition->type = POPPLER_PAGE_TRANSITION_WIPE;
>	break;
>      case transitionDissolve:
>        transition->type = POPPLER_PAGE_TRANSITION_DISSOLVE;
>	break;
>      case transitionGlitter:
>        transition->type = POPPLER_PAGE_TRANSITION_GLITTER;
>	break;
>      case transitionFly:
>        transition->type = POPPLER_PAGE_TRANSITION_FLY;
>	break;
>      case transitionPush:
>        transition->type = POPPLER_PAGE_TRANSITION_PUSH;
>	break;
>      case transitionCover:
>        transition->type = POPPLER_PAGE_TRANSITION_COVER;
>	break;
>      case transitionUncover:
>        transition->type = POPPLER_PAGE_TRANSITION_UNCOVER;
>        break;
>      case transitionFade:
>        transition->type = POPPLER_PAGE_TRANSITION_FADE;
>	break;
>      default:
>        g_assert_not_reached ();
>    }
>
>  transition->alignment = (trans->getAlignment() == transitionHorizontal) ?
>	  POPPLER_PAGE_TRANSITION_HORIZONTAL :
>	  POPPLER_PAGE_TRANSITION_VERTICAL;
>
>  transition->direction = (trans->getDirection() == transitionInward) ?
>	  POPPLER_PAGE_TRANSITION_INWARD :
>	  POPPLER_PAGE_TRANSITION_OUTWARD;
>
>  transition->duration = trans->getDuration();
>  transition->angle = trans->getAngle();
>  transition->scale = trans->getScale();
>  transition->rectangular = trans->isRectangular();
>  
>  delete trans;
>  
>  return transition;
>}
>
>#if !defined (HAVE_CAIRO)
>static TextOutputDev *
>poppler_page_get_text_output_dev (PopplerPage *page)
>{
>  if (page->text_dev == NULL) {
>    page->text_dev = new TextOutputDev (NULL, gTrue, gFalse, gFalse);
>
>    if (page->gfx)
>      delete page->gfx;
>    page->gfx = page->page->createGfx(page->text_dev,
>				      72.0, 72.0, 0,
>				      gFalse, /* useMediaBox */
>				      gTrue, /* Crop */
>				      -1, -1, -1, -1,
>				      gFalse, /* printing */
>				      page->document->doc->getCatalog (),
>				      NULL, NULL, NULL, NULL);
>
>    page->page->display(page->gfx);
>
>    page->text_dev->endPage();
>  }
>
>  return page->text_dev;
>}
>#endif /* !defined (HAVE_CAIRO) */
>
>#if defined (HAVE_CAIRO)
>
>static TextPage *
>poppler_page_get_text_page (PopplerPage *page)
>{
>  if (page->text == NULL) {
>    cairo_t *cr;
>    cairo_surface_t *surface;
>
>    surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 1, 1);
>    cr = cairo_create (surface);
>    poppler_page_render (page, cr);
>    cairo_destroy (cr);
>    cairo_surface_destroy (surface);
>
>  }
>
>  return page->text;
>}
>
>#ifdef POPPLER_WITH_GDK
>typedef struct {
>  unsigned char *cairo_data;
>  cairo_surface_t *surface;
>  cairo_t *cairo;
>} OutputDevData;
>
>static void
>poppler_page_prepare_output_dev (PopplerPage *page,
>				 double scale,
>				 int rotation,
>				 gboolean transparent,
>				 OutputDevData *output_dev_data)
>{
>  CairoOutputDev *output_dev;
>  cairo_surface_t *surface;
>  double width, height;
>  int cairo_width, cairo_height, cairo_rowstride, rotate;
>  unsigned char *cairo_data;
>
>  rotate = rotation + page->page->getRotate ();
>  if (rotate == 90 || rotate == 270) {
>    height = page->page->getCropWidth ();
>    width = page->page->getCropHeight ();
>  } else {
>    width = page->page->getCropWidth ();
>    height = page->page->getCropHeight ();
>  }
>
>  cairo_width = (int) ceil(width * scale);
>  cairo_height = (int) ceil(height * scale);
>
>  output_dev = page->document->output_dev;
>  cairo_rowstride = cairo_width * 4;
>  cairo_data = (guchar *) gmallocn (cairo_height, cairo_rowstride);
>  if (transparent)
>      memset (cairo_data, 0x00, cairo_height * cairo_rowstride);
>  else
>      memset (cairo_data, 0xff, cairo_height * cairo_rowstride);
>
>  surface = cairo_image_surface_create_for_data(cairo_data,
>						CAIRO_FORMAT_ARGB32,
>	  					cairo_width, cairo_height, 
>						cairo_rowstride);
>
>  output_dev_data->cairo_data = cairo_data;
>  output_dev_data->surface = surface;
>  output_dev_data->cairo = cairo_create (surface);
>  output_dev->setCairo (output_dev_data->cairo);
>}
>
>static void
>copy_cairo_surface_to_pixbuf (cairo_surface_t *surface,
>			      unsigned char   *data,
>			      GdkPixbuf       *pixbuf)
>{
>  int cairo_width, cairo_height, cairo_rowstride;
>  unsigned char *pixbuf_data, *dst, *cairo_data;
>  int pixbuf_rowstride, pixbuf_n_channels;
>  unsigned int *src;
>  int x, y;
>
>  cairo_width = cairo_image_surface_get_width (surface);
>  cairo_height = cairo_image_surface_get_height (surface);
>  cairo_rowstride = cairo_width * 4;
>  cairo_data = data;
>
>  pixbuf_data = gdk_pixbuf_get_pixels (pixbuf);
>  pixbuf_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
>  pixbuf_n_channels = gdk_pixbuf_get_n_channels (pixbuf);
>
>  if (cairo_width > gdk_pixbuf_get_width (pixbuf))
>    cairo_width = gdk_pixbuf_get_width (pixbuf);
>  if (cairo_height > gdk_pixbuf_get_height (pixbuf))
>    cairo_height = gdk_pixbuf_get_height (pixbuf);
>  for (y = 0; y < cairo_height; y++)
>    {
>      src = (unsigned int *) (cairo_data + y * cairo_rowstride);
>      dst = pixbuf_data + y * pixbuf_rowstride;
>      for (x = 0; x < cairo_width; x++) 
>	{
>	  dst[0] = (*src >> 16) & 0xff;
>	  dst[1] = (*src >> 8) & 0xff; 
>	  dst[2] = (*src >> 0) & 0xff;
>	  if (pixbuf_n_channels == 4)
>	      dst[3] = (*src >> 24) & 0xff;
>	  dst += pixbuf_n_channels;
>	  src++;
>	}
>    }
>}	
>
>static void
>poppler_page_copy_to_pixbuf (PopplerPage *page,
>			     GdkPixbuf *pixbuf,
>			     OutputDevData *output_dev_data)
>{
>  copy_cairo_surface_to_pixbuf (output_dev_data->surface,
>				output_dev_data->cairo_data,
>				pixbuf);
>  
>  page->document->output_dev->setCairo (NULL);
>  cairo_surface_destroy (output_dev_data->surface);
>  cairo_destroy (output_dev_data->cairo);
>  gfree (output_dev_data->cairo_data);
>}
>
>static void
>poppler_page_set_selection_alpha (PopplerPage           *page,
>				  double                 scale,
>				  GdkPixbuf             *pixbuf,
>				  PopplerSelectionStyle  style,
>				  PopplerRectangle      *selection)
>{
>  /* Cairo doesn't need this, since cairo generates an alpha channel. */ 
>}
>#endif /* POPPLER_WITH_GDK */
>
>#elif defined (HAVE_SPLASH) && defined (POPPLER_WITH_GDK)
> 
>typedef struct {
>} OutputDevData;
>
>static void
>poppler_page_prepare_output_dev (PopplerPage *page,
>				 double scale,
>				 int rotation,
>				 gboolean transparent,
>				 OutputDevData *output_dev_data)
>{
>  /* pft */
>}
>
>static void
>poppler_page_copy_to_pixbuf(PopplerPage *page,
>			    GdkPixbuf *pixbuf,
>			    OutputDevData *data)
>{
>  SplashOutputDev *output_dev;
>  SplashBitmap *bitmap;
>  SplashColorPtr color_ptr;
>  int splash_width, splash_height, splash_rowstride;
>  int pixbuf_rowstride, pixbuf_n_channels;
>  guchar *pixbuf_data, *dst;
>  int x, y;
>
>  output_dev = page->document->output_dev;
>
>  bitmap = output_dev->getBitmap ();
>  color_ptr = bitmap->getDataPtr ();
>
>  splash_width = bitmap->getWidth ();
>  splash_height = bitmap->getHeight ();
>  splash_rowstride = bitmap->getRowSize ();
>
>  pixbuf_data = gdk_pixbuf_get_pixels (pixbuf);
>  pixbuf_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
>  pixbuf_n_channels = gdk_pixbuf_get_n_channels (pixbuf);
>
>  if (splash_width > gdk_pixbuf_get_width (pixbuf))
>    splash_width = gdk_pixbuf_get_width (pixbuf);
>  if (splash_height > gdk_pixbuf_get_height (pixbuf))
>    splash_height = gdk_pixbuf_get_height (pixbuf);
>
>  SplashColorPtr pixel = new Guchar[4];
>  for (y = 0; y < splash_height; y++)
>  {
>    dst = pixbuf_data + y * pixbuf_rowstride;
>    for (x = 0; x < splash_width; x++)
>    {
>      output_dev->getBitmap()->getPixel(x, y, pixel);
>      dst[0] = pixel[0];
>      dst[1] = pixel[1];
>      dst[2] = pixel[2];
>      if (pixbuf_n_channels == 4)
>        dst[3] = 0xff;
>      dst += pixbuf_n_channels;
>    }
>  }
>  delete [] pixel;
>}
>
>static void
>poppler_page_set_selection_alpha (PopplerPage           *page,
>				  double                 scale,
>				  GdkPixbuf             *pixbuf,
>				  PopplerSelectionStyle  style,
>				  PopplerRectangle      *selection)
>{
>  GList *region, *l;
>  gint x, y, width, height;
>  int pixbuf_rowstride, pixbuf_n_channels;
>  guchar *pixbuf_data, *dst;
>
>  pixbuf_data = gdk_pixbuf_get_pixels (pixbuf);
>  pixbuf_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
>  pixbuf_n_channels = gdk_pixbuf_get_n_channels (pixbuf);
>  width = gdk_pixbuf_get_width (pixbuf);
>  height = gdk_pixbuf_get_height (pixbuf);
>
>  if (pixbuf_n_channels != 4)
>    return;
>
>  for (y = 0; y < height; y++) {
>      dst = pixbuf_data + y * pixbuf_rowstride;
>      for (x = 0; x < width; x++) {
>	  dst[3] = 0x00;
>	  dst += pixbuf_n_channels;
>      }
>  }
>
>  region = poppler_page_get_selection_region (page, scale, style, selection);
>
>  for (l = region; l; l = g_list_next (l)) {
>    PopplerRectangle *rectangle = (PopplerRectangle *)l->data;
>    GdkRectangle rect;
>    
>    rect.x = (gint)rectangle->x1;
>    rect.y = (gint)rectangle->y1;
>    rect.width  = (gint) (rectangle->x2 - rectangle->x1);
>    rect.height = (gint) (rectangle->y2 - rectangle->y1);
>    
>    for (y = 0; y < rect.height; y++) {
>      dst = pixbuf_data + (rect.y + y) * pixbuf_rowstride +
>	rect.x * pixbuf_n_channels;
>      for (x = 0; x < rect.width; x++) {
>	  dst[3] = 0xff;
>	  dst += pixbuf_n_channels;
>      }
>    }
>  }
>
>  poppler_page_selection_region_free (region);
>}
>
>#endif /* HAVE_SPLASH */
>
>static GBool
>poppler_print_annot_cb (Annot *annot, void *user_data)
>{
>  if (annot->getFlags () & Annot::flagPrint)
>    return gTrue;
>  return (annot->getType() == Annot::typeWidget);
>}
>
>#if defined (HAVE_CAIRO)
>
>static void
>_poppler_page_render (PopplerPage *page,
>		      cairo_t *cairo,
>		      GBool printing)
>{
>  CairoOutputDev *output_dev;
>
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>
>  output_dev = page->document->output_dev;
>  output_dev->setCairo (cairo);
>  output_dev->setPrinting (printing);
>
>  if (!printing)
>    output_dev->setTextPage (page->text);
>
>  /* NOTE: instead of passing -1 we should/could use cairo_clip_extents()
>   * to get a bounding box */
>  cairo_save (cairo);
>  page->page->displaySlice(output_dev,
>			   72.0, 72.0, 0,
>			   gFalse, /* useMediaBox */
>			   gTrue, /* Crop */
>			   -1, -1,
>			   -1, -1,
>			   printing,
>			   page->document->doc->getCatalog (),
>			   NULL, NULL,
>			   printing ? poppler_print_annot_cb : NULL, NULL);
>  cairo_restore (cairo);
>
>  output_dev->setCairo (NULL);
>  output_dev->setTextPage (NULL);
>}
>
>/**
> * poppler_page_render:
> * @page: the page to render from
> * @cairo: cairo context to render to
> *
> * Render the page to the given cairo context. This function
> * is for rendering a page that will be displayed. If you want
> * to render a page that will be printed use
> * poppler_page_render_for_printing() instead
> **/
>void
>poppler_page_render (PopplerPage *page,
>		     cairo_t *cairo)
>{
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>
>  if (!page->text)
>    page->text = new TextPage(gFalse);
>
>  _poppler_page_render (page, cairo, gFalse);
>}
>
>/**
> * poppler_page_render_for_printing:
> * @page: the page to render from
> * @cairo: cairo context to render to
> *
> * Render the page to the given cairo context for printing.
> **/
>void
>poppler_page_render_for_printing (PopplerPage *page,
>				  cairo_t *cairo)
>{
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>  
>  _poppler_page_render (page, cairo, gTrue);	
>}
>
>static cairo_surface_t *
>create_surface_from_thumbnail_data (guchar *data,
>				    gint    width,
>				    gint    height,
>				    gint    rowstride)
>{
>  guchar *cairo_pixels;
>  gint cairo_stride;
>  cairo_surface_t *surface;
>  int j;
>
>  surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, width, height);
>  if (cairo_surface_status (surface))
>    return NULL;
>
>  cairo_pixels = cairo_image_surface_get_data (surface);
>  cairo_stride = cairo_image_surface_get_stride (surface);
>
>  for (j = height; j; j--) {
>    guchar *p = data;
>    guchar *q = cairo_pixels;
>    guchar *end = p + 3 * width;
>
>    while (p < end) {
>#if G_BYTE_ORDER == G_LITTLE_ENDIAN
>      q[0] = p[2];
>      q[1] = p[1];
>      q[2] = p[0];
>#else
>      q[1] = p[0];
>      q[2] = p[1];
>      q[3] = p[2];
>#endif
>      p += 3;
>      q += 4;
>    }
>
>    data += rowstride;
>    cairo_pixels += cairo_stride;
>  }
>
>  return surface;
>}
>				    
>
>/**
> * poppler_page_get_thumbnail:
> * @page: the #PopperPage to get the thumbnail for
> * 
> * Get the embedded thumbnail for the specified page.  If the document
> * doesn't have an embedded thumbnail for the page, this function
> * returns %NULL.
> * 
> * Return value: the tumbnail as a cairo_surface_t or %NULL if the document
> * doesn't have a thumbnail for this page.
> **/
>cairo_surface_t *
>poppler_page_get_thumbnail (PopplerPage *page)
>{
>  unsigned char *data;
>  int width, height, rowstride;
>  cairo_surface_t *surface;
>
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), FALSE);
>
>  if (!page->page->loadThumb (&data, &width, &height, &rowstride))
>    return NULL;
>
>  surface = create_surface_from_thumbnail_data (data, width, height, rowstride);
>  gfree (data);
>  
>  return surface;
>}
>
>/**
> * poppler_page_render_selection:
> * @page: the #PopplerPage for which to render selection
> * @cairo: cairo context to render to
> * @selection: start and end point of selection as a rectangle
> * @old_selection: previous selection
> * @style: a #PopplerSelectionStyle
> * @glyph_color: color to use for drawing glyphs
> * @background_color: color to use for the selection background
> *
> * Render the selection specified by @selection for @page to
> * the given cairo context.  The selection will be rendered, using
> * @glyph_color for the glyphs and @background_color for the selection
> * background.
> *
> * If non-NULL, @old_selection specifies the selection that is already
> * rendered to @cairo, in which case this function will (some day)
> * only render the changed part of the selection.
> **/
>void
>poppler_page_render_selection (PopplerPage           *page,
>			       cairo_t               *cairo,
>			       PopplerRectangle      *selection,
>			       PopplerRectangle      *old_selection,
>			       PopplerSelectionStyle  style, 
>			       PopplerColor          *glyph_color,
>			       PopplerColor          *background_color)
>{
>  CairoOutputDev *output_dev;
>  TextPage *text;
>  SelectionStyle selection_style = selectionStyleGlyph;
>  PDFRectangle pdf_selection(selection->x1, selection->y1,
>			     selection->x2, selection->y2);
>
>  GfxColor gfx_background_color = {
>      {
>	  background_color->red,
>	  background_color->green,
>	  background_color->blue
>      }
>  };
>  GfxColor gfx_glyph_color = {
>      {
>	  glyph_color->red,
>	  glyph_color->green,
>	  glyph_color->blue
>      }
>  };
>
>  switch (style)
>    {
>      case POPPLER_SELECTION_GLYPH:
>        selection_style = selectionStyleGlyph;
>	break;
>      case POPPLER_SELECTION_WORD:
>        selection_style = selectionStyleWord;
>	break;
>      case POPPLER_SELECTION_LINE:
>        selection_style = selectionStyleLine;
>	break;
>    }
>
>  output_dev = page->document->output_dev;
>  output_dev->setCairo (cairo);
>
>  text = poppler_page_get_text_page (page);
>  text->drawSelection (output_dev, 1.0, 0,
>		       &pdf_selection, selection_style,
>		       &gfx_glyph_color, &gfx_background_color);
>
>  output_dev->setCairo (NULL);
>}
>
>#endif /* HAVE_CAIRO */
>
>#ifdef POPPLER_WITH_GDK
>static void
>_poppler_page_render_to_pixbuf (PopplerPage *page,
>				int src_x, int src_y,
>				int src_width, int src_height,
>				double scale,
>				int rotation,
>				GBool printing,
>				GdkPixbuf *pixbuf)
>{
>  OutputDevData data;
>  
>  poppler_page_prepare_output_dev (page, scale, rotation, FALSE, &data);
>
>  page->page->displaySlice(page->document->output_dev,
>			   72.0 * scale, 72.0 * scale,
>			   rotation,
>			   gFalse, /* useMediaBox */
>			   gTrue, /* Crop */
>			   src_x, src_y,
>			   src_width, src_height,
>			   printing,
>			   page->document->doc->getCatalog (),
>			   NULL, NULL,
>			   printing ? poppler_print_annot_cb : NULL, NULL);
>  
>  poppler_page_copy_to_pixbuf (page, pixbuf, &data);
>}
>
>/**
> * poppler_page_render_to_pixbuf:
> * @page: the page to render from
> * @src_x: x coordinate of upper left corner  
> * @src_y: y coordinate of upper left corner  
> * @src_width: width of rectangle to render  
> * @src_height: height of rectangle to render
> * @scale: scale specified as pixels per point
> * @rotation: rotate the document by the specified degree
> * @pixbuf: pixbuf to render into
> *
> * First scale the document to match the specified pixels per point,
> * then render the rectangle given by the upper left corner at
> * (src_x, src_y) and src_width and src_height.
> * This function is for rendering a page that will be displayed.
> * If you want to render a page that will be printed use
> * poppler_page_render_to_pixbuf_for_printing() instead
> **/
>void
>poppler_page_render_to_pixbuf (PopplerPage *page,
>			       int src_x, int src_y,
>			       int src_width, int src_height,
>			       double scale,
>			       int rotation,
>			       GdkPixbuf *pixbuf)
>{
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>  g_return_if_fail (scale > 0.0);
>  g_return_if_fail (pixbuf != NULL);
>
>  _poppler_page_render_to_pixbuf (page, src_x, src_y,
>				  src_width, src_height,
>				  scale, rotation,
>				  gFalse,
>				  pixbuf);
>}
>
>/**
> * poppler_page_render_to_pixbuf_for_printing:
> * @page: the page to render from
> * @src_x: x coordinate of upper left corner  
> * @src_y: y coordinate of upper left corner  
> * @src_width: width of rectangle to render  
> * @src_height: height of rectangle to render
> * @scale: scale specified as pixels per point
> * @rotation: rotate the document by the specified degree
> * @pixbuf: pixbuf to render into
> *
> * First scale the document to match the specified pixels per point,
> * then render the rectangle given by the upper left corner at
> * (src_x, src_y) and src_width and src_height.
> * This function is for rendering a page that will be printed.
> **/
>void
>poppler_page_render_to_pixbuf_for_printing (PopplerPage *page,
>					    int src_x, int src_y,
>					    int src_width, int src_height,
>					    double scale,
>					    int rotation,
>					    GdkPixbuf *pixbuf)
>{
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>  g_return_if_fail (scale > 0.0);
>  g_return_if_fail (pixbuf != NULL);
>
>  _poppler_page_render_to_pixbuf (page, src_x, src_y,
>				  src_width, src_height,
>				  scale, rotation,
>				  gTrue,
>				  pixbuf);
>}
>
>/**
> * poppler_page_get_thumbnail_pixbuf:
> * @page: the #PopperPage to get the thumbnail for
> * 
> * Get the embedded thumbnail for the specified page.  If the document
> * doesn't have an embedded thumbnail for the page, this function
> * returns %NULL.
> * 
> * Return value: the tumbnail as a #GdkPixbuf or %NULL if the document
> * doesn't have a thumbnail for this page.
> **/
>GdkPixbuf *
>poppler_page_get_thumbnail_pixbuf (PopplerPage *page)
>{
>  unsigned char *data;
>  int width, height, rowstride;
>
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), FALSE);
>
>  if (!page->page->loadThumb (&data, &width, &height, &rowstride))
>    return NULL;
>
>  return gdk_pixbuf_new_from_data (data, GDK_COLORSPACE_RGB,
>				   FALSE, 8, width, height, rowstride,
>				   (GdkPixbufDestroyNotify)gfree, NULL);
>}
>
>/**
> * poppler_page_render_selection_to_pixbuf:
> * @page: the #PopplerPage for which to render selection
> * @scale: scale specified as pixels per point
> * @rotation: rotate the document by the specified degree
> * @pixbuf: pixbuf to render to
> * @selection: start and end point of selection as a rectangle
> * @old_selection: previous selection
> * @style: a #PopplerSelectionStyle
> * @glyph_color: color to use for drawing glyphs
> * @background_color: color to use for the selection background
> * 
> * Render the selection specified by @selection for @page into
> * @pixbuf.  The selection will be rendered at @scale, using
> * @glyph_color for the glyphs and @background_color for the selection
> * background.
> *
> * If non-NULL, @old_selection specifies the selection that is already
> * rendered in @pixbuf, in which case this function will (some day)
> * only render the changed part of the selection.
> **/
>void
>poppler_page_render_selection_to_pixbuf (PopplerPage           *page,
>                                         gdouble                scale,
>                                         int                    rotation,
>                                         GdkPixbuf             *pixbuf,
>                                         PopplerRectangle      *selection,
>                                         PopplerRectangle      *old_selection,
>					 PopplerSelectionStyle  style,
>                                         GdkColor              *glyph_color,
>                                         GdkColor              *background_color)
>{
>  OutputDev *output_dev;
>  OutputDevData data;
>  SelectionStyle selection_style = selectionStyleGlyph;
>  PDFRectangle pdf_selection(selection->x1, selection->y1,
>			     selection->x2, selection->y2);
>
>  GfxColor gfx_background_color = { 
>      {
>	  background_color->red,
>	  background_color->green,
>	  background_color->blue
>      }
>  };
>  GfxColor gfx_glyph_color = {
>      {
>	  glyph_color->red,
>	  glyph_color->green,
>	  glyph_color->blue
>      }
>  };
>
>  switch (style)
>    {
>      case POPPLER_SELECTION_GLYPH:
>        selection_style = selectionStyleGlyph;
>	break;
>      case POPPLER_SELECTION_WORD:
>        selection_style = selectionStyleWord;
>	break;
>      case POPPLER_SELECTION_LINE:
>        selection_style = selectionStyleLine;
>	break;
>    }
>
>  output_dev = page->document->output_dev;
>
>  poppler_page_prepare_output_dev (page, scale, rotation, TRUE, &data);
>
>#if defined (HAVE_CAIRO)
>  TextPage *text;
>
>  text = poppler_page_get_text_page (page);
>  text->drawSelection (output_dev, scale, rotation,
>			   &pdf_selection, selection_style,
>			   &gfx_glyph_color, &gfx_background_color);
>#else
>  TextOutputDev *text_dev;
>
>  text_dev = poppler_page_get_text_output_dev (page);
>  text_dev->drawSelection (output_dev, scale, rotation,
>			   &pdf_selection, selection_style,
>			   &gfx_glyph_color, &gfx_background_color);
>  /* We'll need a function to destroy page->text_dev and page->gfx
>   * when the application wants to get rid of them.
>   *
>   * Two improvements: 1) make GfxFont refcounted and let TextPage and
>   * friends hold a reference to the GfxFonts they need so we can free
>   * up Gfx early.  2) use a TextPage directly when rendering the page
>   * so we don't have to use TextOutputDev and render a second
>   * time. */
>#endif
>  
>  poppler_page_copy_to_pixbuf (page, pixbuf, &data);
>
>  poppler_page_set_selection_alpha (page, scale, pixbuf, style, selection);
>}
>
>#endif /* POPPLER_WITH_GDK */
>
>/**
> * poppler_page_get_thumbnail_size:
> * @page: A #PopplerPage
> * @width: return location for width
> * @height: return location for height
> *
> * Returns %TRUE if @page has a thumbnail associated with it.  It also
> * fills in @width and @height with the width and height of the
> * thumbnail.  The values of width and height are not changed if no
> * appropriate thumbnail exists.
> *
> * Return value: %TRUE, if @page has a thumbnail associated with it.
> **/
>gboolean
>poppler_page_get_thumbnail_size (PopplerPage *page,
>				 int         *width,
>				 int         *height)
>{
>  Object thumb;
>  Dict *dict;
>  gboolean retval = FALSE;
>
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), FALSE);
>  g_return_val_if_fail (width != NULL, FALSE);
>  g_return_val_if_fail (height != NULL, FALSE);
>
>  page->page->getThumb (&thumb);
>  if (!thumb.isStream ())
>    {
>      thumb.free ();
>      return FALSE;
>    }
>
>  dict = thumb.streamGetDict();
>
>  /* Theoretically, this could succeed and you would still fail when
>   * loading the thumb */
>  if (dict->lookupInt ("Width", "W", width)  &&
>      dict->lookupInt ("Height", "H", height))
>    retval = TRUE;
>
>  thumb.free ();
>
>  return retval;
>}
>
>/**
> * poppler_page_get_selection_region:
> * @page: a #PopplerPage
> * @scale: scale specified as pixels per point
> * @style: a #PopplerSelectionStyle
> * @selection: start and end point of selection as a rectangle
> * 
> * Returns a region containing the area that would be rendered by
> * poppler_page_render_selection() or 
> * poppler_page_render_selection_to_pixbuf() as a #GList of
> * #PopplerRectangle. The returned list must be freed with
> * poppler_page_selection_region_free().
> * 
> * Return value: a #GList of #PopplerRectangle
> **/
>GList *
>poppler_page_get_selection_region (PopplerPage           *page,
>				   gdouble                scale,
>				   PopplerSelectionStyle  style,
>				   PopplerRectangle      *selection)
>{
>  PDFRectangle poppler_selection;
>  SelectionStyle selection_style = selectionStyleGlyph;
>  GooList *list;
>  GList *region = NULL;
>  int i;
>
>  poppler_selection.x1 = selection->x1;
>  poppler_selection.y1 = selection->y1;
>  poppler_selection.x2 = selection->x2;
>  poppler_selection.y2 = selection->y2;
>
>  switch (style)
>    {
>      case POPPLER_SELECTION_GLYPH:
>        selection_style = selectionStyleGlyph;
>	break;
>      case POPPLER_SELECTION_WORD:
>        selection_style = selectionStyleWord;
>	break;
>      case POPPLER_SELECTION_LINE:
>        selection_style = selectionStyleLine;
>	break;
>    }
>
>#if defined (HAVE_CAIRO)
>  TextPage *text;
>
>  text = poppler_page_get_text_page (page);
>  list = text->getSelectionRegion(&poppler_selection,
>				  selection_style, scale);
>#else
>  TextOutputDev *text_dev;
>  
>  text_dev = poppler_page_get_text_output_dev (page);
>  list = text_dev->getSelectionRegion(&poppler_selection,
>				      selection_style, scale);
>#endif
>  
>  for (i = 0; i < list->getLength(); i++) {
>    PDFRectangle *selection_rect = (PDFRectangle *) list->get(i);
>    PopplerRectangle *rect;
>
>    rect = poppler_rectangle_new ();
>    
>    rect->x1 = selection_rect->x1;
>    rect->y1 = selection_rect->y1;
>    rect->x2 = selection_rect->x2;
>    rect->y2 = selection_rect->y2;
>    
>    region = g_list_prepend (region, rect);
>    
>    delete selection_rect;
>  }
>
>  delete list;
>
>  return g_list_reverse (region);
>}
>
>void
>poppler_page_selection_region_free (GList *region)
>{
>  if (!region)
>    return;
>
>  g_list_foreach (region, (GFunc)poppler_rectangle_free, NULL);
>  g_list_free (region);
>}
>
>/**
> * poppler_page_get_text:
> * @page: a #PopplerPage
> * @style: a #PopplerSelectionStyle
> * @selection: the #PopplerRectangle including the text
> * 
> * Retrieves the contents of the specified @selection as text.
> * 
> * Return value: a pointer to the contents of the @selection
> *               as a string
> **/
>char *
>poppler_page_get_text (PopplerPage          *page,
>		       PopplerSelectionStyle style,
>		       PopplerRectangle     *selection)
>{
>  GooString *sel_text;
>  double height;
>  char *result;
>  SelectionStyle selection_style = selectionStyleGlyph;
>  PDFRectangle pdf_selection;
>
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), FALSE);
>  g_return_val_if_fail (selection != NULL, NULL);
>
>  poppler_page_get_size (page, NULL, &height);
>  pdf_selection.x1 = selection->x1;
>  pdf_selection.y1 = height - selection->y2;
>  pdf_selection.x2 = selection->x2;
>  pdf_selection.y2 = height - selection->y1;
>
>  switch (style)
>    {
>      case POPPLER_SELECTION_GLYPH:
>        selection_style = selectionStyleGlyph;
>	break;
>      case POPPLER_SELECTION_WORD:
>        selection_style = selectionStyleWord;
>	break;
>      case POPPLER_SELECTION_LINE:
>        selection_style = selectionStyleLine;
>	break;
>    }
>
>#if defined (HAVE_CAIRO)
>  TextPage *text;
>
>  text = poppler_page_get_text_page (page);
>  sel_text = text->getSelectionText (&pdf_selection, selection_style);
>#else
>  TextOutputDev *text_dev;
>
>  text_dev = poppler_page_get_text_output_dev (page);
>  sel_text = text_dev->getSelectionText (&pdf_selection, selection_style);
>#endif
>	  
>  result = g_strdup (sel_text->getCString ());
>  delete sel_text;
>
>  return result;
>}
>
>GBool
>poppler_page_scan_text_cache(TextCachePage *text_cache_page, Unicode *s, int len,
>			     GBool caseSensitive, GBool backward)
>{
>  Unicode *s2;
>  Unicode *upper_s2;
>  int i, k;
>
>  s2 = unicodeNormalizeNFKC(s, len, &len, NULL);
>
>  // convert the search string to uppercase
>  if (!caseSensitive) {
>    upper_s2 = unicodeNormalizeNFKC(s, len, &len, NULL);
>    for (i = 0; i < len; ++i)
>      upper_s2[i] = g_unichar_toupper(upper_s2[i]);
>  }
>
>  i = 0;
>  while (i + len <= text_cache_page->len) {
>    k = 0;
>    while (k < len && ((s2[k] == text_cache_page->text[i+k]) || (!caseSensitive && (upper_s2[k] == text_cache_page->text[i+k]))))
>      k++;
>    if (k == len)
>      break;
>    i++;
>  }
>
>  return (k == len);
>}
>
>/**
> * poppler_page_find_text:
> * @page: a #PopplerPage
> * @text: the text to search for (UTF-8 encoded)
> * 
> * A #GList of rectangles for each occurance of the text on the page.
> * The coordinates are in PDF points.
> * 
> * Return value: a #GList of PopplerRectangle, 
> **/
>GList *
>poppler_page_find_text (PopplerPage *page,
>			const char  *text)
>{
>  PopplerRectangle *match;
>  GList *matches;
>  double xMin, yMin, xMax, yMax;
>  gunichar *ucs4;
>  glong ucs4_len;
>  double height;
>  TextOutputDev *text_dev;
>  static TextCachePage *text_cache;
>  static int text_cache_size;
>  int i;
>
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), FALSE);
>  g_return_val_if_fail (text != NULL, FALSE);
>
>  if (page->index >= text_cache_size) {
>    text_cache = (TextCachePage *) realloc(text_cache, (page->index + 1) * sizeof(struct TextCachePage));
>    for (i = text_cache_size; i <= page->index; i++)
>      text_cache[i].len = -1;
>    text_cache_size = page->index + 1;
>  }
>
>  ucs4 = g_utf8_to_ucs4_fast (text, -1, &ucs4_len);
>  matches = NULL;
>
>
>  if ((text_cache[page->index].len == -1) ||
>      poppler_page_scan_text_cache(&(text_cache[page->index]), ucs4, ucs4_len, gFalse, gFalse)) {
>  
>    text_dev = new TextOutputDev (NULL, gTrue, gFalse, gFalse);
>    page->page->display (text_dev, 72, 72, 0,
>		         gFalse, gTrue, gFalse,
>		         page->document->doc->getCatalog());
>
>    poppler_page_get_size (page, NULL, &height);
>  
>    xMin = 0;
>    yMin = 0;
>
>    while (text_dev->findText (ucs4, ucs4_len,
>			       gFalse, gTrue, // startAtTop, stopAtBottom
>			       gTrue, gFalse, // startAtLast, stopAtLast
>			       gFalse, gFalse, // caseSensitive, backwards
>			       &xMin, &yMin, &xMax, &yMax))
>      {
>        match = g_new (PopplerRectangle, 1);
>        match->x1 = xMin;
>        match->y1 = height - yMax;
>        match->x2 = xMax;
>        match->y2 = height - yMin;
>        matches = g_list_prepend (matches, match);
>      }
>
>    if (text_cache[page->index].len == -1) {
>      text_dev->cacheText(&(text_cache[page->index]));
>    }
>
>    delete text_dev;
>  }
>  
>  g_free (ucs4);
>
>  return g_list_reverse (matches);
>}
>
>#if defined (HAVE_CAIRO)
>
>static CairoImageOutputDev *
>poppler_page_get_image_output_dev (PopplerPage *page,
>				   GBool (*imgDrawDeviceCbk)(int img_id, void *data),
>				   void *imgDrawCbkData)
>{
>  CairoImageOutputDev *image_dev;
>  Gfx *gfx;
>  
>  image_dev = new CairoImageOutputDev ();
>
>  if (imgDrawDeviceCbk) {
>    image_dev->setImageDrawDecideCbk (imgDrawDeviceCbk,
>				      imgDrawCbkData);
>  }
>
>  gfx = page->page->createGfx(image_dev,
>			      72.0, 72.0, 0,
>			      gFalse, /* useMediaBox */
>			      gTrue, /* Crop */
>			      -1, -1, -1, -1,
>			      gFalse, /* printing */
>			      page->document->doc->getCatalog (),
>			      NULL, NULL, NULL, NULL);
>  page->page->display(gfx);
>  delete gfx;
>
>  return image_dev;
>}
>
>/**
> * poppler_page_get_image_mapping:
> * @page: A #PopplerPage
> *
> * Returns a list of #PopplerImageMapping items that map from a
> * location on @page to an image of the page. This list must be freed
> * with poppler_page_free_image_mapping() when done.
> *
> * Return value: A #GList of #PopplerImageMapping
> **/
>GList *
>poppler_page_get_image_mapping (PopplerPage *page)
>{
>  GList *map_list = NULL;
>  CairoImageOutputDev *out;
>  gint i;
>  
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), NULL);
>
>  out = poppler_page_get_image_output_dev (page, NULL, NULL);
>
>  for (i = 0; i < out->getNumImages (); i++) {
>    PopplerImageMapping *mapping;
>    CairoImage *image;
>
>    image = out->getImage (i);
>
>    /* Create the mapping */
>    mapping = g_new (PopplerImageMapping, 1);
>
>    image->getRect (&(mapping->area.x1), &(mapping->area.y1),
>		    &(mapping->area.x2), &(mapping->area.y2));
>    mapping->image_id = i;
>    
>    mapping->area.x1 -= page->page->getCropBox()->x1;
>    mapping->area.x2 -= page->page->getCropBox()->x1;
>    mapping->area.y1 -= page->page->getCropBox()->y1;
>    mapping->area.y2 -= page->page->getCropBox()->y1;
>
>    map_list = g_list_prepend (map_list, mapping);
>  }
>
>  delete out;
>
>  return map_list;	
>}
>
>static GBool
>image_draw_decide_cb (int image_id, void *data)
>{
>  return (image_id == GPOINTER_TO_INT (data));
>}
>
>/**
> * poppler_page_get_image:
> * @page: A #PopplerPage
> * @image_id: The image identificator
> *
> * Returns a cairo surface for the image of the @page
> *
> * Return value: A cairo surface for the image
> **/
>cairo_surface_t *
>poppler_page_get_image (PopplerPage *page,
>			gint         image_id)
>{
>  CairoImageOutputDev *out;
>  cairo_surface_t *image;
>  
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), NULL);
>
>  out = poppler_page_get_image_output_dev (page,
>					   image_draw_decide_cb,
>					   GINT_TO_POINTER (image_id));
>
>  if (image_id >= out->getNumImages ()) {
>    delete out;
>    
>    return NULL;
>  }
>
>  image = out->getImage (image_id)->getImage ();
>  if (!image) {
>    delete out;
>
>    return NULL;
>  }
>
>  cairo_surface_reference (image);
>  delete out;
>  
>  return image;
>}
>
>/**
> * poppler_page_free_image_mapping:
> * @list: A list of #PopplerImageMappings
> *
> * Frees a list of #PopplerImageMappings allocated by
> * poppler_page_get_image_mapping().
> **/
>void
>poppler_page_free_image_mapping (GList *list)
>{
>  if (list == NULL)
>    return;
>
>  g_list_foreach (list, (GFunc)g_free, NULL);
>  g_list_free (list);
>}
>
>#else /* HAVE_CAIRO */
>
>GList *
>poppler_page_get_image_mapping (PopplerPage *page)
>{
>  return NULL;
>}
>
>void
>poppler_page_free_image_mapping (GList *list)
>{
>}
>
>#endif /* HAVE_CAIRO */
>
>/**
> * poppler_page_render_to_ps:
> * @page: a #PopplerPage
> * @ps_file: the PopplerPSFile to render to
> * 
> * Render the page on a postscript file
> * 
> **/
>void
>poppler_page_render_to_ps (PopplerPage   *page,
>			   PopplerPSFile *ps_file)
>{
>  g_return_if_fail (POPPLER_IS_PAGE (page));
>  g_return_if_fail (ps_file != NULL);
>
>  if (!ps_file->out)
>    ps_file->out = new PSOutputDev (ps_file->filename,
>                                    ps_file->document->doc->getXRef(),
>                                    ps_file->document->doc->getCatalog(),
>                                    NULL,
>                                    ps_file->first_page, ps_file->last_page,
>                                    psModePS, (int)ps_file->paper_width,
>                                    (int)ps_file->paper_height, ps_file->duplex,
>                                    0, 0, 0, 0, gFalse, gFalse);
>
>
>  ps_file->document->doc->displayPage (ps_file->out, page->index + 1, 72.0, 72.0,
>				       0, gFalse, gTrue, gFalse);
>}
>
>static void
>poppler_page_get_property (GObject *object,
>			   guint prop_id,
>			   GValue *value,
>			   GParamSpec *pspec)
>{
>  PopplerPage *page = POPPLER_PAGE (object);
>  GooString label;
>
>  switch (prop_id)
>    {
>    case PROP_LABEL:
>      page->document->doc->getCatalog ()->indexToLabel (page->index, &label);
>      g_value_take_string (value, _poppler_goo_string_to_utf8(&label));
>      break;
>    }
>}
>
>static void
>poppler_page_class_init (PopplerPageClass *klass)
>{
>  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
>  GParamSpec *pspec;
>
>  gobject_class->finalize = poppler_page_finalize;
>  gobject_class->get_property = poppler_page_get_property;
>
>  pspec = g_param_spec_string ("label",
>			       "Page Label",
>			       "The label of the page",
>			       NULL,
>			       G_PARAM_READABLE);
>  g_object_class_install_property (G_OBJECT_CLASS (klass),
>				   PROP_LABEL,
>				   pspec);
>}
>
>static void
>poppler_page_init (PopplerPage *page)
>{
>}
>
>/**
> * poppler_page_get_link_mapping:
> * @page: A #PopplerPage
> * 
> * Returns a list of #PopplerLinkMapping items that map from a
> * location on @page to a #PopplerAction.  This list must be freed
> * with poppler_page_free_link_mapping() when done.
> * 
> * Return value: A #GList of #PopplerLinkMapping
> **/
>GList *
>poppler_page_get_link_mapping (PopplerPage *page)
>{
>  GList *map_list = NULL;
>  gint i;
>  Links *links;
>  Object obj;
>  double width, height;
>  
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), NULL);
>  
>  links = new Links (page->page->getAnnots (&obj),
>		     page->document->doc->getCatalog ()->getBaseURI ());
>  obj.free ();
>  
>  if (links == NULL)
>    return NULL;
>  
>  poppler_page_get_size (page, &width, &height);
>  
>  for (i = 0; i < links->getNumLinks (); i++)
>    {
>      PopplerLinkMapping *mapping;
>      PopplerRectangle rect;
>      LinkAction *link_action;
>      Link *link;
>      
>      link = links->getLink (i);
>      link_action = link->getAction ();
>      
>      /* Create the mapping */
>      mapping = g_new (PopplerLinkMapping, 1);
>      mapping->action = _poppler_action_new (page->document, link_action, NULL);
>      
>      link->getRect (&rect.x1, &rect.y1, &rect.x2, &rect.y2);
>      
>      switch (page->page->getRotate ())
>        {
>        case 90:
>	  mapping->area.x1 = rect.y1;
>	  mapping->area.y1 = height - rect.x2;
>	  mapping->area.x2 = mapping->area.x1 + (rect.y2 - rect.y1);
>	  mapping->area.y2 = mapping->area.y1 + (rect.x2 - rect.x1);
>	  
>	  break;
>	case 180:
>	  mapping->area.x1 = width - rect.x2;
>	  mapping->area.y1 = height - rect.y2;
>	  mapping->area.x2 = mapping->area.x1 + (rect.x2 - rect.x1);
>	  mapping->area.y2 = mapping->area.y1 + (rect.y2 - rect.y1);
>	  
>	  break;
>	case 270:
>	  mapping->area.x1 = width - rect.y2;
>	  mapping->area.y1 = rect.x1;
>	  mapping->area.x2 = mapping->area.x1 + (rect.y2 - rect.y1);
>	  mapping->area.y2 = mapping->area.y1 + (rect.x2 - rect.x1);
>	  
>	  break;
>	default:
>	  mapping->area.x1 = rect.x1;
>	  mapping->area.y1 = rect.y1;
>	  mapping->area.x2 = rect.x2;
>	  mapping->area.y2 = rect.y2;
>	}
>			
>      mapping->area.x1 -= page->page->getCropBox()->x1;
>      mapping->area.x2 -= page->page->getCropBox()->x1;
>      mapping->area.y1 -= page->page->getCropBox()->y1;
>      mapping->area.y2 -= page->page->getCropBox()->y1;
>      
>      map_list = g_list_prepend (map_list, mapping);
>    }
>  
>  delete links;
>  
>  return map_list;
>}
>
>static void
>poppler_mapping_free (PopplerLinkMapping *mapping)
>{
>  poppler_action_free (mapping->action);
>  g_free (mapping);
>}
>
>/**
> * poppler_page_free_link_mapping:
> * @list: A list of #PopplerLinkMappings
> * 
> * Frees a list of #PopplerLinkMappings allocated by
> * poppler_page_get_link_mapping().  It also frees the #PopplerActions
> * that each mapping contains, so if you want to keep them around, you need to
> * copy them with poppler_action_copy().
> **/
>void
>poppler_page_free_link_mapping (GList *list)
>{
>  if (list == NULL)
>    return;
>
>  g_list_foreach (list, (GFunc) (poppler_mapping_free), NULL);
>  g_list_free (list);
>}
>
>/**
> * poppler_page_get_form_field_mapping:
> * @page: A #PopplerPage
> *
> * Returns a list of #PopplerFormFieldMapping items that map from a
> * location on @page to a form field.  This list must be freed
> * with poppler_page_free_form_field_mapping() when done.
> *
> * Return value: A #GList of #PopplerFormFieldMapping
> **/
>GList *
>poppler_page_get_form_field_mapping (PopplerPage *page)
>{
>  GList *map_list = NULL;
>  FormPageWidgets *forms;
>  gint i;
>  
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), NULL);
>
>  forms = page->page->getPageWidgets ();
>  if (forms == NULL)
>    return NULL;
>  
>  for (i = 0; i < forms->getNumWidgets (); i++) {
>    PopplerFormFieldMapping *mapping;
>    FormWidget *field;
>
>    mapping = poppler_form_field_mapping_new ();
>    
>    field = forms->getWidget (i);
>
>    mapping->field = _poppler_form_field_new (page->document, field);
>    field->getRect (&(mapping->area.x1), &(mapping->area.y1),
>		    &(mapping->area.x2), &(mapping->area.y2));
>
>    mapping->area.x1 -= page->page->getCropBox()->x1;
>    mapping->area.x2 -= page->page->getCropBox()->x1;
>    mapping->area.y1 -= page->page->getCropBox()->y1;
>    mapping->area.y2 -= page->page->getCropBox()->y1;
>    
>    map_list = g_list_prepend (map_list, mapping);
>  }
>  
>  return map_list;
>}
>
>/**
> * poppler_page_free_form_field_mapping:
> * @list: A list of #PopplerFormFieldMappings
> *
> * Frees a list of #PopplerFormFieldMappings allocated by
> * poppler_page_get_form_field_mapping().
> **/
>void
>poppler_page_free_form_field_mapping (GList *list)
>{
>  if (list == NULL)
>    return;
>
>  g_list_foreach (list, (GFunc) poppler_form_field_mapping_free, NULL);
>  g_list_free (list);
>}
>
>/**
> * poppler_page_get_annot_mapping:
> * @page: A #PopplerPage
> *
> * Returns a list of #PopplerAnnotMapping items that map from a location on
> * @page to a #PopplerAnnot.  This list must be freed with
> * poppler_page_free_annot_mapping() when done.
> *
> * Return value: A #GList of #PopplerAnnotMapping
> **/
>GList *
>poppler_page_get_annot_mapping (PopplerPage *page)
>{
>  GList *map_list = NULL;
>  double width, height;
>  gint i;
>
>  g_return_val_if_fail (POPPLER_IS_PAGE (page), NULL);
>
>  if (!page->annots)
>    page->annots = page->page->getAnnots (page->document->doc->getCatalog ());
>  
>  if (!page->annots)
>    return NULL;
>
>  poppler_page_get_size (page, &width, &height);
>
>  for (i = 0; i < page->annots->getNumAnnots (); i++) {
>    PopplerAnnotMapping *mapping;
>    PopplerRectangle rect;
>    Annot *annot;
>    PDFRectangle *annot_rect;
>    gint rotation = 0;
>
>    annot = page->annots->getAnnot (i);
>
>    /* Create the mapping */
>    mapping = poppler_annot_mapping_new ();
>
>    switch (annot->getType ())
>      {
>      case Annot::typeText:
>        mapping->annot = _poppler_annot_text_new (annot);
>	break;
>      case Annot::typeFreeText:
>        mapping->annot = _poppler_annot_free_text_new (annot);
>	break;
>      default:
>        mapping->annot = _poppler_annot_new (annot);
>	break;
>      }
>
>    annot_rect = annot->getRect ();
>    rect.x1 = annot_rect->x1;
>    rect.y1 = annot_rect->y1;
>    rect.x2 = annot_rect->x2;
>    rect.y2 = annot_rect->y2;
>
>    if (! (annot->getFlags () & Annot::flagNoRotate))
>      rotation = page->page->getRotate ();
>
>    switch (rotation)
>      {
>      case 90:
>        mapping->area.x1 = rect.y1;
>        mapping->area.y1 = height - rect.x2;
>        mapping->area.x2 = mapping->area.x1 + (rect.y2 - rect.y1);
>        mapping->area.y2 = mapping->area.y1 + (rect.x2 - rect.x1);
>        break;
>      case 180:
>        mapping->area.x1 = width - rect.x2;
>        mapping->area.y1 = height - rect.y2;
>        mapping->area.x2 = mapping->area.x1 + (rect.x2 - rect.x1);
>        mapping->area.y2 = mapping->area.y1 + (rect.y2 - rect.y1);
>        break;
>      case 270:
>        mapping->area.x1 = width - rect.y2;
>        mapping->area.y1 = rect.x1;
>        mapping->area.x2 = mapping->area.x1 + (rect.y2 - rect.y1);
>        mapping->area.y2 = mapping->area.y1 + (rect.x2 - rect.x1);
>        break;
>      default:
>        mapping->area.x1 = rect.x1;
>        mapping->area.y1 = rect.y1;
>        mapping->area.x2 = rect.x2;
>        mapping->area.y2 = rect.y2;
>      }
>
>    mapping->area.x1 -= page->page->getCropBox()->x1;
>    mapping->area.x2 -= page->page->getCropBox()->x1;
>    mapping->area.y1 -= page->page->getCropBox()->y1;
>    mapping->area.y2 -= page->page->getCropBox()->y1;
>
>    map_list = g_list_prepend (map_list, mapping);
>  }
>
>  return g_list_reverse (map_list);
>}
>
>/**
> * poppler_page_free_annot_mapping:
> * @list: A list of #PopplerAnnotMappings
> *
> * Frees a list of #PopplerAnnotMappings allocated by
> * poppler_page_get_annot_mapping().  It also frees the #PopplerAnnots
> * that each mapping contains, so if you want to keep them around, you need to
> * copy them with poppler_annot_copy().
> **/
>void
>poppler_page_free_annot_mapping (GList *list)
>{
>  if (!list)
>    return;
>
>  g_list_foreach (list, (GFunc)poppler_annot_mapping_free, NULL);
>  g_list_free (list);
>}
>
>/* PopplerRectangle type */
>
>POPPLER_DEFINE_BOXED_TYPE (PopplerRectangle, poppler_rectangle,
>			   poppler_rectangle_copy,
>			   poppler_rectangle_free)
>
>PopplerRectangle *
>poppler_rectangle_new (void)
>{
>  return g_new0 (PopplerRectangle, 1);
>}
>
>PopplerRectangle *
>poppler_rectangle_copy (PopplerRectangle *rectangle)
>{
>  PopplerRectangle *new_rectangle;
>
>  g_return_val_if_fail (rectangle != NULL, NULL);
>  
>  new_rectangle = g_new (PopplerRectangle, 1);
>  *new_rectangle = *rectangle;
>
>  return new_rectangle;
>}
>
>void
>poppler_rectangle_free (PopplerRectangle *rectangle)
>{
>  g_free (rectangle);
>}
>
>/* PopplerColor type */
>POPPLER_DEFINE_BOXED_TYPE (PopplerColor, poppler_color, poppler_color_copy, poppler_color_free)
>
>PopplerColor *
>poppler_color_new (void)
>{
>  return (PopplerColor *) g_new0 (PopplerColor, 1);
>}
>
>PopplerColor *
>poppler_color_copy (PopplerColor *color)
>{
>  PopplerColor *new_color;
>
>  new_color = g_new (PopplerColor, 1);
>  *new_color = *color;
>
>  return new_color;
>}
>
>void
>poppler_color_free (PopplerColor *color)
>{
>  g_free (color);
>}
>
>/* PopplerLinkMapping type */
>POPPLER_DEFINE_BOXED_TYPE (PopplerLinkMapping, poppler_link_mapping,
>			   poppler_link_mapping_copy,
>			   poppler_link_mapping_free)
>
>PopplerLinkMapping *
>poppler_link_mapping_new (void)
>{
>  return (PopplerLinkMapping *) g_new0 (PopplerLinkMapping, 1);
>}
>
>PopplerLinkMapping *
>poppler_link_mapping_copy (PopplerLinkMapping *mapping)
>{
>  PopplerLinkMapping *new_mapping;
>
>  new_mapping = poppler_link_mapping_new ();
>	
>  *new_mapping = *mapping;
>  if (new_mapping->action)
>    new_mapping->action = poppler_action_copy (new_mapping->action);
>
>  return new_mapping;
>}
>
>void
>poppler_link_mapping_free (PopplerLinkMapping *mapping)
>{
>  if (mapping->action)
>    poppler_action_free (mapping->action);
>
>  g_free (mapping);
>}
>
>/* Poppler Image mapping type */
>POPPLER_DEFINE_BOXED_TYPE (PopplerImageMapping, poppler_image_mapping,
>			   poppler_image_mapping_copy,
>			   poppler_image_mapping_free)
>
>PopplerImageMapping *
>poppler_image_mapping_new (void)
>{
>  return (PopplerImageMapping *) g_new0 (PopplerImageMapping, 1);
>}
>
>PopplerImageMapping *
>poppler_image_mapping_copy (PopplerImageMapping *mapping)
>{
>  PopplerImageMapping *new_mapping;
>
>  new_mapping = poppler_image_mapping_new ();
>
>  *new_mapping = *mapping;
>
>  return new_mapping;
>}
>
>void
>poppler_image_mapping_free (PopplerImageMapping *mapping)
>{
>  g_free (mapping);
>}
>
>/* Page Transition */
>POPPLER_DEFINE_BOXED_TYPE (PopplerPageTransition, poppler_page_transition,
>			   poppler_page_transition_copy,
>			   poppler_page_transition_free)
>
>PopplerPageTransition *
>poppler_page_transition_new (void)
>{
>  return (PopplerPageTransition *) g_new0 (PopplerPageTransition, 1);
>}
>
>PopplerPageTransition *
>poppler_page_transition_copy (PopplerPageTransition *transition)
>{
>  PopplerPageTransition *new_transition;
>
>  new_transition = poppler_page_transition_new ();
>  *new_transition = *transition;
>  
>  return new_transition;
>}
>
>void
>poppler_page_transition_free (PopplerPageTransition *transition)
>{
>  g_free (transition);
>}
>
>/* Form Field Mapping Type */
>POPPLER_DEFINE_BOXED_TYPE (PopplerFormFieldMapping, poppler_form_field_mapping,
>			   poppler_form_field_mapping_copy,
>			   poppler_form_field_mapping_free)
>
>PopplerFormFieldMapping *
>poppler_form_field_mapping_new (void)
>{
>  return (PopplerFormFieldMapping *) g_new0 (PopplerFormFieldMapping, 1);
>}
>
>PopplerFormFieldMapping *
>poppler_form_field_mapping_copy (PopplerFormFieldMapping *mapping)
>{
>  PopplerFormFieldMapping *new_mapping;
>  
>  new_mapping = poppler_form_field_mapping_new ();
>  *new_mapping = *mapping;
>
>  if (mapping->field)
>	  new_mapping->field = (PopplerFormField *)g_object_ref (mapping->field);
>	    
>  return new_mapping;
>}
>
>void
>poppler_form_field_mapping_free (PopplerFormFieldMapping *mapping)
>{
>  if (!mapping)
>    return;
>
>  if (mapping->field)
>    g_object_unref (mapping->field);
>  
>  g_free (mapping);
>}
>
>/* PopplerAnnot Mapping Type */
>POPPLER_DEFINE_BOXED_TYPE (PopplerAnnotMapping, poppler_annot_mapping,
>			   poppler_annot_mapping_copy,
>			   poppler_annot_mapping_free)
>
>PopplerAnnotMapping *
>poppler_annot_mapping_new (void)
>{
>  return (PopplerAnnotMapping *) g_new0 (PopplerAnnotMapping, 1);
>}
>
>PopplerAnnotMapping *
>poppler_annot_mapping_copy (PopplerAnnotMapping *mapping)
>{
>  PopplerAnnotMapping *new_mapping;
>
>  new_mapping = poppler_annot_mapping_new ();
>
>  *new_mapping = *mapping;
>  if (mapping->annot)
>    new_mapping->annot = (PopplerAnnot *) g_object_ref (mapping->annot);
>
>  return new_mapping;
>}
>
>void
>poppler_annot_mapping_free (PopplerAnnotMapping *mapping)
>{
>  if (!mapping)
>    return;
>
>  if (mapping->annot)
>    g_object_unref (mapping->annot);
>
>  g_free (mapping);
>}
>
>void 
>poppler_page_get_crop_box (PopplerPage *page, PopplerRectangle *rect)
>{
>  PDFRectangle* cropBox = page->page->getCropBox ();
>  
>  rect->x1 = cropBox->x1;
>  rect->x2 = cropBox->x2;
>  rect->y1 = cropBox->y1;
>  rect->y2 = cropBox->y2;
>}
>

Actions: View | Splinter Review

Attachments on bug 28053: 45937 | 45938 | 45939

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.