Merge lp:~ubuntu-branches/ubuntu/precise/apvlv/precise-201112121632 into lp:ubuntu/precise/apvlv

[Ubuntu Package Importer]

The package importer has detected a possible inconsistency between the package history in the archive and the history in bzr. As the archive is authoritative the importer has made lp:ubuntu/precise/apvlv reflect what is in the archive and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/precise/apvlv/precise-201112121632. This merge proposal was created so that an Ubuntu developer can review the situations and perform a merge/upload if necessary. There are three typical cases where this can happen.
  1. Where someone pushes a change to bzr and someone else uploads the package without that change. This is the reason that this check is done by the importer. If this appears to be the case then a merge/upload should be done if the changes that were in bzr are still desirable.
  2. The importer incorrectly detected the above situation when someone made a change in bzr and then uploaded it.
  3. The importer incorrectly detected the above situation when someone just uploaded a package and didn't touch bzr.

If this case doesn't appear to be the first situation then set the status of the merge proposal to "Rejected" and help avoid the problem in future by filing a bug at https://bugs.launchpad.net/udd linking to this merge proposal.

(this is an automatically generated message)

Unmerged revisions

20. By Martin Pitt on 2011-12-12

releasing version 0.1.1-1.1ubuntu1

19. By Martin Pitt on 2011-12-12

Add 00git_poppler_render_to_pixbuf.patch: Add poppler_render_to_pixbuf
function for poppler no gdkpixbuf support. Patch taken from upstream git
head.

18. By Martin Pitt on 2011-12-12

debian/source/format: Switch to 3.0 (quilt), to be able to apply patches.

=== added directory '.pc'
=== added file '.pc/.quilt_patches'
--- .pc/.quilt_patches	1970-01-01 00:00:00 +0000
+++ .pc/.quilt_patches	2011-12-12 16:38:24 +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	2011-12-12 16:38:24 +0000
@@ -0,0 +1,1 @@
+series

=== added file '.pc/.version'
--- .pc/.version	1970-01-01 00:00:00 +0000
+++ .pc/.version	2011-12-12 16:38:24 +0000
@@ -0,0 +1,1 @@
+2

=== added directory '.pc/00git_poppler_render_to_pixbuf.patch'
=== added file '.pc/00git_poppler_render_to_pixbuf.patch/.timestamp'
=== added directory '.pc/00git_poppler_render_to_pixbuf.patch/src'
=== added file '.pc/00git_poppler_render_to_pixbuf.patch/src/ApvlvFile.cpp'
--- .pc/00git_poppler_render_to_pixbuf.patch/src/ApvlvFile.cpp	1970-01-01 00:00:00 +0000
+++ .pc/00git_poppler_render_to_pixbuf.patch/src/ApvlvFile.cpp	2011-12-12 16:38:24 +0000
@@ -0,0 +1,907 @@
+/*
+* This file is part of the apvlv package
+* Copyright (C) <2008>  <Alf>
+*
+* Contact: Alf <[e-mail]>
+*
+* 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 of the License, 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.
+*
+*/
+/* @CFILE ApvlvFile.cpp xxxxxxxxxxxxxxxxxxxxxxxxxx.
+*
+*  Author: Alf <[e-mail]>
+*/
+/* @date Created: 2009/11/20 19:38:30 Alf*/
+
+#include "ApvlvFile.hpp"
+#include "ApvlvUtil.hpp"
+#include "ApvlvView.hpp"
+
+#ifdef HAVE_LIBUMD
+#define LIBUMD_ENABLE_GTK
+#include <umd.h>
+#endif
+#include <glib.h>
+
+#include <sys/stat.h>
+#include <iostream>
+#include <fstream>
+
+namespace apvlv
+  {
+#ifndef MAX
+#define MAX(a,b)        ((a) > (b) ? (a) : (b))
+#endif
+
+  ApvlvFile::ApvlvFile (const char *filename, bool check)
+  {
+    mIndex = NULL;
+
+    mRawdata = NULL;
+    mRawdataSize = 0;
+  }
+
+  ApvlvFile::~ApvlvFile ()
+  {
+    if (mRawdata != NULL)
+      {
+        delete[]mRawdata;
+        mRawdata = NULL;
+      }
+  }
+
+  ApvlvFile *ApvlvFile::newfile (const char *filename, bool check)
+  {
+    ApvlvFile *file = NULL;
+    static const char *type_phrase[] =
+    {
+      ".PDF",
+      ".umd",
+      ".djvu"
+    };
+
+    size_t i;
+    for (i = 0; i < 3; ++ i)
+      {
+        if (strcasecmp (filename + strlen (filename) - strlen (type_phrase[i]),
+                        type_phrase[i]) == 0)
+          {
+            break;
+          }
+      }
+
+    if (i == 3)
+      {
+        debug ("not a valid file: %s, treate as a PDF file", filename);
+        i = 0;
+      }
+
+    try
+      {
+        switch (i)
+          {
+          case 0:
+            file = new ApvlvPDF (filename);
+            break;
+
+          case 1:
+            file = new ApvlvUMD (filename);
+            break;
+
+          case 2:
+            file = new ApvlvDJVU (filename);
+            break;
+
+          default:
+            ;
+          }
+      }
+
+    catch (bad_alloc e)
+      {
+        delete file;
+        file = NULL;
+      }
+
+    return file;
+  }
+
+  ApvlvPDF::ApvlvPDF (const char *filename, bool check):ApvlvFile (filename,
+          check)
+  {
+    gchar *wfilename;
+
+    if (filename == NULL
+        || *filename == '\0'
+        || g_file_test (filename, G_FILE_TEST_IS_REGULAR) == FALSE
+        || (wfilename =
+              g_locale_from_utf8 (filename, -1, NULL, NULL, NULL)) == NULL)
+      {
+        gView->errormessage ("filename error: %s",
+                             filename ? filename : "No name");
+        throw std::bad_alloc ();
+      }
+
+    size_t filelen;
+    struct stat sbuf;
+    int rt = stat (wfilename, &sbuf);
+    if (rt < 0)
+      {
+        gView->errormessage ("Can't stat the PDF file: %s.", filename);
+        throw std::bad_alloc ();
+      }
+    filelen = sbuf.st_size;
+
+    if (mRawdata != NULL && mRawdataSize < filelen)
+      {
+        delete[]mRawdata;
+        mRawdata = NULL;
+      }
+
+    if (mRawdata == NULL)
+      {
+        mRawdata = new char[filelen];
+        mRawdataSize = filelen;
+      }
+
+    ifstream ifs (wfilename, ios::binary);
+    if (ifs.is_open ())
+      {
+        ifs.read (mRawdata, filelen);
+        ifs.close ();
+      }
+
+    g_free (wfilename);
+
+    GError *error = NULL;
+    mDoc = poppler_document_new_from_data (mRawdata, filelen, NULL, &error);
+
+    if (mDoc == NULL && error && error->code == POPPLER_ERROR_ENCRYPTED)
+      {
+        GtkWidget *dia = gtk_message_dialog_new (NULL,
+                         GTK_DIALOG_DESTROY_WITH_PARENT,
+                         GTK_MESSAGE_QUESTION,
+                         GTK_BUTTONS_OK_CANCEL,
+                         "%s", error->message);
+        g_error_free (error);
+
+
+        GtkWidget *entry = gtk_entry_new ();
+        gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
+        gtk_entry_set_invisible_char (GTK_ENTRY (entry), '*');
+        gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dia)->vbox), entry, TRUE,
+                            TRUE, 10);
+        gtk_widget_show (entry);
+
+        int ret = gtk_dialog_run (GTK_DIALOG (dia));
+        if (ret == GTK_RESPONSE_OK)
+          {
+            gchar *ans = (gchar *) gtk_entry_get_text (GTK_ENTRY (entry));
+            if (ans != NULL)
+              {
+                mDoc =
+                  poppler_document_new_from_data (mRawdata, filelen, ans,
+                                                  NULL);
+              }
+          }
+
+        gtk_widget_destroy (dia);
+      }
+
+    if (mDoc == NULL)
+      {
+        throw std::bad_alloc ();
+      }
+  }
+
+  ApvlvPDF::~ApvlvPDF ()
+  {
+    if (mDoc)
+      {
+        g_object_unref (mDoc);
+      }
+  }
+
+  bool ApvlvPDF::writefile (const char *filename)
+  {
+    debug ("write %p to %s", this, filename);
+    gchar *path = absolutepath (filename);
+    if (path == NULL)
+      {
+        debug ("filename error: %s", filename);
+        return false;
+      }
+
+    GError *error = NULL;
+    gchar *uri = g_filename_to_uri (path, NULL, &error);
+    g_free (path);
+    if (uri == NULL && error)
+      {
+        debug ("%d: %s", error->code, error->message);
+        return false;
+      }
+
+    if (mDoc && uri != NULL)
+      {
+        gboolean ret = poppler_document_save (mDoc, uri, NULL);
+        debug ("write pdf: %p to %s, return %d", mDoc, uri, ret);
+        g_free (uri);
+        return ret == TRUE ? true : false;
+      }
+    return false;
+  }
+
+  bool ApvlvPDF::pagesize (int pn, int rot, double *x, double *y)
+  {
+    PopplerPage *page = poppler_document_get_page (mDoc, pn);
+    if (page != NULL)
+      {
+        if (rot == 90 || rot == 270)
+          {
+            poppler_page_get_size (page, y, x);
+          }
+        else
+          {
+            poppler_page_get_size (page, x, y);
+          }
+        return true;
+      }
+    return false;
+  }
+
+  int ApvlvPDF::pagesum ()
+  {
+    return mDoc ? poppler_document_get_n_pages (mDoc) : 0;
+  }
+
+  ApvlvPoses *ApvlvPDF::pagesearch (int pn, const char *str, bool reverse)
+  {
+    PopplerPage *page = poppler_document_get_page (mDoc, pn);
+    if (page == NULL)
+      {
+        return NULL;
+      }
+
+//    debug ("search %s", str);
+
+    GList *list = poppler_page_find_text (page, str);
+    if (list == NULL)
+      {
+        return NULL;
+      }
+
+    if (reverse)
+      {
+        list = g_list_reverse (list);
+      }
+
+    ApvlvPoses *poses = new ApvlvPoses;
+    for (GList * tmp = list; tmp != NULL; tmp = g_list_next (tmp))
+      {
+        PopplerRectangle *rect = (PopplerRectangle *) tmp->data;
+//      debug ("results: %f-%f,%f-%f", rect->x1, rect->x2, rect->y1,
+//             rect->y2);
+        ApvlvPos pos = { rect->x1, rect->x2, rect->y1, rect->y2 };
+        poses->push_back (pos);
+      }
+
+    return poses;
+  }
+
+  bool ApvlvPDF::pagetext (int pn, int x1, int y1, int x2, int y2, char **out)
+  {
+    PopplerPage *page = poppler_document_get_page (mDoc, pn);
+#if POPPLER_CHECK_VERSION(0, 15, 1)
+    PopplerRectangle rect = { x1, y2, x2, y1 };
+    *out = poppler_page_get_selected_text (page, POPPLER_SELECTION_WORD, &rect);
+#else
+    PopplerRectangle rect = { x1, y1, x2, y2 };
+    *out = poppler_page_get_text (page, POPPLER_SELECTION_WORD, &rect);
+#endif
+    if (*out != NULL)
+      {
+        return true;
+      }
+    return false;
+  }
+
+  bool ApvlvPDF::render (int pn, int ix, int iy, double zm, int rot,
+                         GdkPixbuf * pix, char *buffer)
+  {
+    PopplerPage *tpage;
+
+    if ((tpage = poppler_document_get_page (mDoc, pn)) == NULL)
+      {
+        debug ("no this page: %d", pn);
+        return false;
+      }
+
+    poppler_page_render_to_pixbuf (tpage, 0, 0, ix, iy, zm, rot, pix);
+    return true;
+  }
+
+  bool ApvlvPDF::pageselectsearch (int pn, int ix, int iy,
+                                   double zm, int rot, GdkPixbuf * pix,
+                                   char *buffer, int sel, ApvlvPoses * poses)
+  {
+    ApvlvPos rect = (*poses)[sel];
+
+    // Caculate the correct position
+    //debug ("pagex: %f, pagey: %f, x1: %f, y1: %f, x2: %f, y2: %f", pagex, pagey, rect->x1, rect->y1, rect->x2, rect->y2);
+    gint x1 = MAX (rect.x1 * zm + 0.5, 0);
+    gint x2 = MAX (rect.x2 * zm - 0.5, 1);
+    gint y1 = MAX ((iy - rect.y2 * zm) + 0.5, 0);
+    gint y2 = MAX ((iy - rect.y1 * zm) - 0.5, 1);
+    //debug ("x1: %d, y1: %d, x2: %d, y2: %d", x1, y1, x2, y2);
+
+    // heightlight the selection
+    for (gint y = y1; y < y2; y++)
+      {
+        for (gint x = x1; x < x2; x++)
+          {
+            gint p = (gint) (y * ix * 3 + (x * 3));
+            buffer[p + 0] = 0xff - buffer[p + 0];
+            buffer[p + 1] = 0xff - buffer[p + 0];
+            buffer[p + 2] = 0xff - buffer[p + 0];
+          }
+      }
+
+    // change the back color of the selection
+    for (ApvlvPoses::const_iterator itr = poses->begin ();
+         itr != poses->end (); itr++)
+      {
+        // Caculate the correct position
+        x1 = (gint) (itr->x1 * zm);
+        x2 = (gint) (itr->x2 * zm);
+        y1 = (gint) (iy - itr->y2 * zm);
+        y2 = (gint) (iy - itr->y1 * zm);
+
+        for (gint y = y1; y < y2; y++)
+          {
+            for (gint x = x1; x < x2; x++)
+              {
+                gint p = (gint) (y * 3 * ix + (x * 3));
+                buffer[p + 0] = 0xff - buffer[p + 0];
+                buffer[p + 1] = 0xff - buffer[p + 0];
+                buffer[p + 2] = 0xff - buffer[p + 0];
+              }
+          }
+      }
+
+    return true;
+  }
+
+  ApvlvLinks *ApvlvPDF::getlinks (int pn)
+  {
+    PopplerPage *page = poppler_document_get_page (mDoc, pn);
+    GList *list = poppler_page_get_link_mapping (page);
+    if (list == NULL)
+      {
+        return NULL;
+      }
+
+    ApvlvLinks *links = new ApvlvLinks;
+
+    for (GList * tmp = list; tmp != NULL; tmp = g_list_next (tmp))
+      {
+        PopplerLinkMapping *map = (PopplerLinkMapping *) tmp->data;
+        if (map)
+          {
+            PopplerAction *act = map->action;
+            if (act && *(PopplerActionType *) act == POPPLER_ACTION_GOTO_DEST)
+              {
+                PopplerDest *pd = ((PopplerActionGotoDest *) act)->dest;
+                if (pd->type == POPPLER_DEST_NAMED)
+                  {
+                    PopplerDest *destnew = poppler_document_find_dest (mDoc,
+                                           pd->named_dest);
+                    if (destnew != NULL)
+                      {
+                        ApvlvLink link = { "", destnew->page_num - 1 };
+                        links->insert (links->begin (), link);
+                        poppler_dest_free (destnew);
+                      }
+                  }
+                else
+                  {
+                    ApvlvLink link = { "", pd->page_num - 1 };
+                    links->insert (links->begin (), link);
+                  }
+              }
+          }
+      }
+
+    return links;
+  }
+
+  ApvlvFileIndex *ApvlvPDF::new_index ()
+  {
+    if (mIndex != NULL)
+      {
+        debug ("file %p has index: %p, return", this, mIndex);
+        return mIndex;
+      }
+
+    PopplerIndexIter *itr = poppler_index_iter_new (mDoc);
+    if (itr == NULL)
+      {
+        debug ("no index.");
+        return NULL;
+      }
+
+    mIndex = new ApvlvFileIndex;
+    walk_poppler_index_iter (mIndex, itr);
+    poppler_index_iter_free (itr);
+
+    return mIndex;
+  }
+
+  void ApvlvPDF::free_index (ApvlvFileIndex * index)
+  {
+    delete index;
+  }
+
+  bool ApvlvPDF::walk_poppler_index_iter (ApvlvFileIndex * titr,
+                                          PopplerIndexIter * iter)
+  {
+    bool has = false;
+    do
+      {
+        has = false;
+        ApvlvFileIndex *index = NULL;
+
+        PopplerAction *act = poppler_index_iter_get_action (iter);
+        if (act)
+          {
+            if (*(PopplerActionType *) act == POPPLER_ACTION_GOTO_DEST)
+              {
+                PopplerActionGotoDest *pagd = (PopplerActionGotoDest *) act;
+                if (pagd->dest->type == POPPLER_DEST_NAMED)
+                  {
+                    PopplerDest *destnew = poppler_document_find_dest (mDoc,
+                                           pagd->
+                                           dest->
+                                           named_dest);
+                    int pn = 1;
+                    if (destnew != NULL)
+                      {
+                        pn = destnew->page_num - 1;
+                        poppler_dest_free (destnew);
+                      }
+                    index = new ApvlvFileIndex;
+                    index->page = pn;
+                  }
+                else
+                  {
+                    index = new ApvlvFileIndex;
+                    index->page = pagd->dest->page_num - 1;
+                  }
+
+                if (index != NULL)
+                  {
+                    has = true;
+                    index->title = pagd->title;
+                    titr->children.push_back (*index);
+                    delete index;
+                    index = &(titr->children[titr->children.size () - 1]);
+                    debug ("titr: %p, index: %p", titr, index);
+                  }
+              }
+            poppler_action_free (act);
+          }
+
+        PopplerIndexIter *child = poppler_index_iter_get_child (iter);
+        if (child)
+          {
+            bool chas = walk_poppler_index_iter (has ? index : titr, child);
+            has = has ? has : chas;
+            poppler_index_iter_free (child);
+          }
+      }
+    while (poppler_index_iter_next (iter));
+    return has;
+  }
+
+  bool ApvlvPDF::pageprint (int pn, cairo_t * cr)
+  {
+#ifdef WIN32
+    return false;
+#else
+    PopplerPage *page = poppler_document_get_page (mDoc, pn);
+    if (page != NULL)
+      {
+        poppler_page_render_for_printing (page, cr);
+        return true;
+      }
+    else
+      {
+        return false;
+      }
+#endif
+  }
+
+#ifdef HAVE_LIBDJVU
+  void handle_ddjvu_messages (ddjvu_context_t * ctx, int wait)
+  {
+    const ddjvu_message_t *msg;
+    if (wait)
+      ddjvu_message_wait (ctx);
+    while ((msg = ddjvu_message_peek (ctx)))
+      {
+        debug ("tag: %d", msg->m_any.tag);
+        switch (msg->m_any.tag)
+          {
+          case DDJVU_ERROR:
+            break;
+          case DDJVU_INFO:
+            break;
+          case DDJVU_PAGEINFO:
+            break;
+          default:
+            break;
+          }
+        ddjvu_message_pop (ctx);
+      }
+  }
+#endif
+
+  ApvlvDJVU::ApvlvDJVU (const char *filename, bool check):ApvlvFile (filename,
+          check)
+  {
+#ifdef HAVE_LIBDJVU
+    mContext = ddjvu_context_create ("apvlv");
+    if (mContext)
+      {
+        mDoc = ddjvu_document_create_by_filename (mContext, filename, FALSE);
+      }
+
+    if (mDoc != NULL)
+      {
+        if (ddjvu_document_get_type (mDoc) == DDJVU_DOCTYPE_SINGLEPAGE)
+          {
+            debug ("djvu type: %d", ddjvu_document_get_type (mDoc));
+          }
+        else
+          {
+            /*
+               ddjvu_document_release (mDoc);
+               mDoc = NULL;
+               ddjvu_context_release (mContext);
+               mContext = NULL;
+               throw std::bad_alloc (); */
+          }
+      }
+    else
+      {
+        ddjvu_context_release (mContext);
+        mContext = NULL;
+        throw std::bad_alloc ();
+      }
+#else
+    throw std::bad_alloc ();
+#endif
+  }
+
+  ApvlvDJVU::~ApvlvDJVU ()
+  {
+#ifdef HAVE_LIBDJVU
+    if (mContext)
+      {
+        ddjvu_context_release (mContext);
+      }
+
+    if (mDoc)
+      {
+        ddjvu_document_release (mDoc);
+      }
+#endif
+  }
+
+  bool ApvlvDJVU::writefile (const char *filename)
+  {
+#ifdef HAVE_LIBDJVU
+    FILE *fp = fopen (filename, "wb");
+    if (fp != NULL)
+      {
+        ddjvu_job_t *job = ddjvu_document_save (mDoc, fp, 0, NULL);
+        while (!ddjvu_job_done (job))
+          {
+            handle_ddjvu_messages (mContext, TRUE);
+          }
+        fclose (fp);
+        return true;
+      }
+    return false;
+#else
+    return false;
+#endif
+  }
+
+  bool ApvlvDJVU::pagesize (int pn, int rot, double *x, double *y)
+  {
+#ifdef HAVE_LIBDJVU
+    ddjvu_status_t t;
+    ddjvu_pageinfo_t info[1];
+    while ((t = ddjvu_document_get_pageinfo (mDoc, 0, info)) < DDJVU_JOB_OK)
+      {
+        handle_ddjvu_messages (mContext, true);
+      }
+
+    if (t == DDJVU_JOB_OK)
+      {
+        *x = info->width;
+        *y = info->height;
+        debug ("djvu page 1: %f-%f", *x, *y);
+      }
+    return true;
+#else
+    return false;
+#endif
+  }
+
+  int ApvlvDJVU::pagesum ()
+  {
+#ifdef HAVE_LIBDJVU
+    return mDoc ? ddjvu_document_get_pagenum (mDoc) : 0;
+#else
+    return 0;
+#endif
+  }
+
+  bool ApvlvDJVU::render (int pn, int ix, int iy, double zm, int rot,
+                          GdkPixbuf * pix, char *buffer)
+  {
+#ifdef HAVE_LIBDJVU
+    ddjvu_page_t *tpage;
+
+    if ((tpage = ddjvu_page_create_by_pageno (mDoc, pn)) == NULL)
+      {
+        debug ("no this page: %d", pn);
+        return false;
+      }
+
+    ddjvu_rect_t prect[1] = { {0, 0, ix, iy}
+    };
+    ddjvu_rect_t rrect[1] = { {0, 0, ix, iy}
+    };
+    ddjvu_format_t *format =
+      ddjvu_format_create (DDJVU_FORMAT_RGB24, 0, NULL);
+    ddjvu_format_set_row_order (format, TRUE);
+
+    gint retry = 0;
+    while (retry <= 20 && ddjvu_page_render
+           (tpage, DDJVU_RENDER_COLOR, prect, rrect, format, 3 * ix,
+            (char *) buffer) == FALSE)
+      {
+        usleep (50 * 1000);
+        debug ("fender failed, retry %d", ++retry);
+      }
+
+    return true;
+#else
+    return false;
+#endif
+  }
+
+  bool ApvlvDJVU::pageselectsearch (int pn, int ix, int iy, double zm,
+                                    int rot, GdkPixbuf * pix, char *buffer,
+                                    int sel, ApvlvPoses * poses)
+  {
+    return false;
+  }
+
+  ApvlvPoses *ApvlvDJVU::pagesearch (int pn, const char *str, bool reverse)
+  {
+    return NULL;
+  }
+
+  ApvlvLinks *ApvlvDJVU::getlinks (int pn)
+  {
+    return NULL;
+  }
+
+  bool ApvlvDJVU::pagetext (int pn, int x1, int y1, int x2, int y2,
+                            char **out)
+  {
+    return false;
+  }
+
+  ApvlvFileIndex *ApvlvDJVU::new_index ()
+  {
+    return NULL;
+  }
+
+  void ApvlvDJVU::free_index (ApvlvFileIndex * index)
+  {
+  }
+
+  bool ApvlvDJVU::pageprint (int pn, cairo_t * cr)
+  {
+    return false;
+  }
+
+  ApvlvUMD::ApvlvUMD (const char *filename, bool check):ApvlvFile (filename,
+          check)
+  {
+#ifdef HAVE_LIBUMD
+    gchar * lname = g_locale_from_utf8 (filename, -1, NULL, NULL, NULL);
+    if (lname)
+      {
+        mUmd = umd_new_from_file (lname);
+        g_free (lname);
+      }
+    else
+      {
+        mUmd = umd_new_from_file (filename);
+      }
+
+    if (mUmd == NULL)
+      {
+        throw std::bad_alloc ();
+      }
+#else
+    throw std::bad_alloc ();
+#endif
+  }
+
+  ApvlvUMD::~ApvlvUMD ()
+  {
+#ifdef HAVE_LIBUMD
+    if (mUmd)
+      {
+        umd_destroy (mUmd);
+      }
+#endif
+  }
+
+  bool ApvlvUMD::writefile (const char *filename)
+  {
+#ifdef HAVE_LIBUMD
+    if (umd_write_file (mUmd, filename) == 0)
+      {
+        return true;
+      }
+    return false;
+#else
+    return false;
+#endif
+  }
+
+  bool ApvlvUMD::pagesize (int pn, int rot, double *x, double *y)
+  {
+#ifdef HAVE_LIBUMD
+    umd_page_t * page;
+
+    page = umd_get_nth_page (mUmd, pn);
+    if (page)
+      {
+        int ix, iy;
+        umd_page_get_size (page, &ix, &iy);
+        *x = ix;
+        *y = iy;
+        return true;
+      }
+    return false;
+#else
+    return false;
+#endif
+  }
+
+  int ApvlvUMD::pagesum ()
+  {
+#ifdef HAVE_LIBUMD
+    return mUmd ? umd_get_page_n (mUmd) : 0;
+#else
+    return 0;
+#endif
+  }
+
+  bool ApvlvUMD::render (int pn, int ix, int iy, double zm, int rot,
+                         GdkPixbuf * pix, char *buffer)
+  {
+#ifdef HAVE_LIBUMD
+    umd_page_t * page;
+
+    page = umd_get_nth_page (mUmd, pn);
+    if (page)
+      {
+        umd_page_render (page, 0, 0, ix, iy, zm, rot, (unsigned char *) buffer, 3 * ix);
+        return true;
+      }
+    return false;
+#else
+    return false;
+#endif
+  }
+
+  bool ApvlvUMD::pageselectsearch (int pn, int ix, int iy, double zm,
+                                   int rot, GdkPixbuf * pix, char *buffer,
+                                   int sel, ApvlvPoses * poses)
+  {
+    return false;
+  }
+
+  ApvlvPoses *ApvlvUMD::pagesearch (int pn, const char *str, bool reverse)
+  {
+    return NULL;
+  }
+
+  ApvlvLinks *ApvlvUMD::getlinks (int pn)
+  {
+    return NULL;
+  }
+
+  bool ApvlvUMD::pagetext (int pn, int x1, int y1, int x2, int y2,
+                           char **out)
+  {
+    return false;
+  }
+
+  ApvlvFileIndex *ApvlvUMD::new_index ()
+  {
+#ifdef HAVE_LIBUMD
+    if (mIndex != NULL)
+      {
+        debug ("file %p has index: %p, return", this, mIndex);
+        return mIndex;
+      }
+
+    int cpt_n = umd_get_chapter_n (mUmd);
+    if (cpt_n <= 0)
+      {
+        debug ("no index.");
+        return NULL;
+      }
+
+    mIndex = new ApvlvFileIndex;
+    for (int i = 0;
+         i < cpt_n;
+         ++ i)
+      {
+        umd_chapter_t * chapter = umd_get_nth_chapter (mUmd, i);
+        if (chapter)
+          {
+            ApvlvFileIndex inx;
+
+            inx.title = chapter->title;
+            inx.page = chapter->page_index;
+
+            mIndex->children.push_back (inx);
+
+            free (chapter->title);
+            free (chapter->content);
+            free (chapter);
+          }
+      }
+
+    return mIndex;
+#else
+    return NULL;
+#endif
+  }
+
+  void ApvlvUMD::free_index (ApvlvFileIndex * index)
+  {
+#ifdef HAVE_LIBUMD
+    delete mIndex;
+#endif
+  }
+
+  bool ApvlvUMD::pageprint (int pn, cairo_t * cr)
+  {
+    return false;
+  }
+
+}

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2011-12-12 16:38:24 +0000
@@ -0,0 +1,1 @@
+00git_poppler_render_to_pixbuf.patch

=== modified file 'debian/changelog'
--- debian/changelog	2011-12-12 16:54:41 +0000
+++ debian/changelog	2011-12-12 16:38:24 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 apvlv (0.1.1-1.1ubuntu1) precise; urgency=low
 
   * src/ApvlvFile.cpp Add poppler_render_to_pixbuf function for poppler
@@ -6,6 +7,17 @@
 
  -- Martin Pitt <[e-mail]>  Mon, 12 Dec 2011 16:54:41 +0100
 
+=======
+apvlv (0.1.1-1.1ubuntu1) precise; urgency=low
+
+  * debian/source/format: Switch to 3.0 (quilt), to be able to apply patches.
+  * Add 00git_poppler_render_to_pixbuf.patch: Add poppler_render_to_pixbuf
+    function for poppler no gdkpixbuf support. Patch taken from upstream git
+    head.
+
+ -- Martin Pitt <[e-mail]>  Mon, 12 Dec 2011 16:54:41 +0100
+
+>>>>>>> MERGE-SOURCE
 apvlv (0.1.1-1.1) unstable; urgency=low
 
   * Non-maintainer upload.

=== added directory 'debian/patches'
=== added file 'debian/patches/00git_poppler_render_to_pixbuf.patch'
--- debian/patches/00git_poppler_render_to_pixbuf.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/00git_poppler_render_to_pixbuf.patch	2011-12-12 16:38:24 +0000
@@ -0,0 +1,155 @@
+From e5aec2fd102a0f041dc53f4aa8040ab89043e05d Mon Sep 17 00:00:00 2001
+From: Alf <[e-mail]>
+Date: Mon, 17 Oct 2011 10:15:02 +0800
+Subject: add poppler_render_to_pixbuf function for poppler no gdkpixbuf support
+
+---
+ src/ApvlvPdf.cc |  135 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 1 files changed, 135 insertions(+), 0 deletions(-)
+
+Index: apvlv/src/ApvlvFile.cpp
+===================================================================
+--- apvlv.orig/src/ApvlvFile.cpp	2011-12-12 16:44:56.000000000 +0100
++++ apvlv/src/ApvlvFile.cpp	2011-12-12 16:51:57.959351280 +0100
+@@ -39,6 +39,141 @@
+ #include <iostream>
+ #include <fstream>
+ 
++#ifndef POPPLER_WITH_GDK
++#include <goo/gtypes.h>
++
++static void
++copy_cairo_surface_to_pixbuf (cairo_surface_t *surface,
++			      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_image_surface_get_stride (surface);
++  cairo_data = cairo_image_surface_get_data (surface);
++
++  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_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)
++{
++  cairo_t *cr;
++  cairo_surface_t *surface;
++
++  surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
++					src_width, src_height);
++  cr = cairo_create (surface);
++  cairo_save (cr);
++  switch (rotation) {
++  case 90:
++	  cairo_translate (cr, src_x + src_width, -src_y);
++	  break;
++  case 180:
++	  cairo_translate (cr, src_x + src_width, src_y + src_height);
++	  break;
++  case 270:
++	  cairo_translate (cr, -src_x, src_y + src_height);
++	  break;
++  default:
++	  cairo_translate (cr, -src_x, -src_y);
++  }
++
++  if (scale != 1.0)
++	  cairo_scale (cr, scale, scale);
++
++  if (rotation != 0)
++	  cairo_rotate (cr, rotation * G_PI / 180.0);
++
++  if (printing)
++	  poppler_page_render_for_printing (page, cr);
++  else
++	  poppler_page_render (page, cr);
++  cairo_restore (cr);
++
++  cairo_set_operator (cr, CAIRO_OPERATOR_DEST_OVER);
++  cairo_set_source_rgb (cr, 1., 1., 1.);
++  cairo_paint (cr);
++
++  cairo_destroy (cr);
++
++  copy_cairo_surface_to_pixbuf (surface, pixbuf);
++  cairo_surface_destroy (surface);
++}
++
++/**
++ * 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
++ *
++ * Deprecated: 0.16
++ **/
++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);
++}
++#endif
++
+ namespace apvlv
+   {
+ #ifndef MAX

=== added file 'debian/patches/series'
--- debian/patches/series	1970-01-01 00:00:00 +0000
+++ debian/patches/series	2011-12-12 16:38:24 +0000
@@ -0,0 +1,1 @@
+00git_poppler_render_to_pixbuf.patch

=== modified file 'debian/source/format'
--- debian/source/format	2011-06-01 22:18:49 +0000
+++ debian/source/format	2011-12-12 16:38:24 +0000
@@ -1,1 +1,1 @@
-1.0
+3.0 (quilt)