diff --git a/autotests/documenttest.cpp b/autotests/documenttest.cpp
index 32617921b..9c12b56d7 100644
--- a/autotests/documenttest.cpp
+++ b/autotests/documenttest.cpp
@@ -1,63 +1,63 @@
 /***************************************************************************
  *   Copyright (C) 2013 by Fabio D'Urso <fabiodurso@hotmail.it>            *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include <QtTest>
 
 #include <threadweaver/queue.h>
 
 #include "../core/document.h"
 #include "../core/generator.h"
 #include "../core/observer.h"
 #include "../core/rotationjob_p.h"
 #include "../settings_core.h"
 
 class DocumentTest
 : public QObject
 {
     Q_OBJECT
 
     private slots:
         void testCloseDuringRotationJob();
 };
 
 // Test that we don't crash if the document is closed while a RotationJob
 // is enqueued/running
 void DocumentTest::testCloseDuringRotationJob()
 {
     Okular::SettingsCore::instance( QStringLiteral("documenttest") );
     Okular::Document *m_document = new Okular::Document( 0 );
     const QString testFile = QStringLiteral(KDESRCDIR "data/file1.pdf");
     QMimeDatabase db;
     const QMimeType mime = db.mimeTypeForFile( testFile );
 
     Okular::DocumentObserver *dummyDocumentObserver = new Okular::DocumentObserver();
     m_document->addObserver( dummyDocumentObserver );
 
     m_document->openDocument( testFile, QUrl(), mime );
     m_document->setRotation( 1 );
 
     // Tell ThreadWeaver not to start any new job
     ThreadWeaver::Queue::instance()->suspend();
 
     // Request a pixmap. A RotationJob will be enqueued but not started
     Okular::PixmapRequest *pixmapReq = new Okular::PixmapRequest(
-        dummyDocumentObserver, 0, 100, 100, 1.0, 1, Okular::PixmapRequest::NoFeature );
+        dummyDocumentObserver, 0, 100, 100, 1, Okular::PixmapRequest::NoFeature );
     m_document->requestPixmaps( QLinkedList<Okular::PixmapRequest*>() << pixmapReq );
 
     // Delete the document
     delete m_document;
 
     // Resume job processing and wait for the RotationJob to finish
     ThreadWeaver::Queue::instance()->resume();
     ThreadWeaver::Queue::instance()->finish();
     qApp->processEvents();
 }
 
 QTEST_MAIN( DocumentTest )
 #include "documenttest.moc"
diff --git a/core/document.cpp b/core/document.cpp
index a667f6929..b725ecfc7 100644
--- a/core/document.cpp
+++ b/core/document.cpp
@@ -1,5197 +1,5195 @@
 /***************************************************************************
  *   Copyright (C) 2004-2005 by Enrico Ros <eros.kde@email.it>             *
  *   Copyright (C) 2004-2008 by Albert Astals Cid <aacid@kde.org>          *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "document.h"
 #include "document_p.h"
 #include "documentcommands_p.h"
 
 #include <limits.h>
 #ifdef Q_OS_WIN
 #define _WIN32_WINNT 0x0500
 #include <windows.h>
 #elif defined(Q_OS_FREEBSD)
 #include <sys/types.h>
 #include <sys/sysctl.h>
 #include <vm/vm_param.h>
 #endif
 
 // qt/kde/system includes
 #include <QtCore/QtAlgorithms>
 #include <QtCore/QDir>
 #include <QtCore/QFile>
 #include <QtCore/QFileInfo>
 #include <QtCore/QMap>
 #include <QtCore/qtemporaryfile.h>
 #include <QtCore/QTextStream>
 #include <QtCore/QTimer>
 #include <QtWidgets/QApplication>
 #include <QtWidgets/QLabel>
 #include <QtPrintSupport/QPrinter>
 #include <QtPrintSupport/QPrintDialog>
 #include <QStack>
 #include <QUndoCommand>
 #include <QMimeDatabase>
 #include <QDesktopServices>
 #include <QPageSize>
 #include <QStandardPaths>
 
 #include <kauthorized.h>
 #include <kconfigdialog.h>
 #include <kmacroexpander.h>
 #include <kmessagebox.h>
 #include <kmimetypetrader.h>
 #include <kprocess.h>
 #include <KRun>
 #include <kshell.h>
 #include <kzip.h>
 #include <KIO/Global>
 #include <KFormat>
 #include <KLocalizedString>
 #include <KPluginMetaData>
 #include <Kdelibs4Migration>
 
 // local includes
 #include "action.h"
 #include "annotations.h"
 #include "annotations_p.h"
 #include "audioplayer.h"
 #include "audioplayer_p.h"
 #include "bookmarkmanager.h"
 #include "chooseenginedialog_p.h"
 #include "debug_p.h"
 #include "generator_p.h"
 #include "interfaces/configinterface.h"
 #include "interfaces/guiinterface.h"
 #include "interfaces/printinterface.h"
 #include "interfaces/saveinterface.h"
 #include "observer.h"
 #include "misc.h"
 #include "page.h"
 #include "page_p.h"
 #include "pagecontroller_p.h"
 #include "scripter.h"
 #include "settings_core.h"
 #include "sourcereference.h"
 #include "sourcereference_p.h"
 #include "texteditors_p.h"
 #include "tile.h"
 #include "tilesmanager_p.h"
 #include "utils_p.h"
 #include "view.h"
 #include "view_p.h"
 #include "form.h"
 #include "utils.h"
 
 #include <memory>
 
 #include <config-okular.h>
 
 using namespace Okular;
 
 struct AllocatedPixmap
 {
     // owner of the page
     DocumentObserver *observer;
     int page;
     qulonglong memory;
     // public constructor: initialize data
     AllocatedPixmap( DocumentObserver *o, int p, qulonglong m ) : observer( o ), page( p ), memory( m ) {}
 };
 
 struct ArchiveData
 {
     ArchiveData()
     {
     }
 
     QTemporaryFile document;
     QTemporaryFile metadataFile;
 };
 
 struct RunningSearch
 {
     // store search properties
     int continueOnPage;
     RegularAreaRect continueOnMatch;
     QSet< int > highlightedPages;
 
     // fields related to previous searches (used for 'continueSearch')
     QString cachedString;
     Document::SearchType cachedType;
     Qt::CaseSensitivity cachedCaseSensitivity;
     bool cachedViewportMove : 1;
     bool isCurrentlySearching : 1;
     QColor cachedColor;
     int pagesDone;
 };
 
 #define foreachObserver( cmd ) {\
     QSet< DocumentObserver * >::const_iterator it=d->m_observers.constBegin(), end=d->m_observers.constEnd();\
     for ( ; it != end ; ++ it ) { (*it)-> cmd ; } }
 
 #define foreachObserverD( cmd ) {\
     QSet< DocumentObserver * >::const_iterator it = m_observers.constBegin(), end = m_observers.constEnd();\
     for ( ; it != end ; ++ it ) { (*it)-> cmd ; } }
 
 #define OKULAR_HISTORY_MAXSTEPS 100
 #define OKULAR_HISTORY_SAVEDSTEPS 10
 
 /***** Document ******/
 
 QString DocumentPrivate::pagesSizeString() const
 {
     if (m_generator)
     {
         if (m_generator->pagesSizeMetric() != Generator::None)
         {
             QSizeF size = m_parent->allPagesSize();
             if (size.isValid()) return localizedSize(size);
             else return QString();
         }
         else return QString();
     }
     else return QString();
 }
 
 QString DocumentPrivate::namePaperSize(double inchesWidth, double inchesHeight) const
 {
     const QPrinter::Orientation orientation = inchesWidth > inchesHeight ? QPrinter::Landscape : QPrinter::Portrait;
 
     const QSize pointsSize(inchesWidth *72.0, inchesHeight*72.0);
     const QPageSize::PageSizeId paperSize = QPageSize::id(pointsSize, QPageSize::FuzzyOrientationMatch);
 
     const QString paperName = QPageSize::name(paperSize);
 
     if (orientation == QPrinter::Portrait) {
         return i18nc("paper type and orientation (eg: Portrait A4)", "Portrait %0").arg(paperName);
     } else {
         return i18nc("paper type and orientation (eg: Portrait A4)", "Landscape %0").arg(paperName);
     }
 }
 
 QString DocumentPrivate::localizedSize(const QSizeF &size) const
 {
     double inchesWidth = 0, inchesHeight = 0;
     switch (m_generator->pagesSizeMetric())
     {
         case Generator::Points:
             inchesWidth = size.width() / 72.0;
             inchesHeight = size.height() / 72.0;
         break;
 
         case Generator::Pixels:
         {
             const QSizeF dpi = m_generator->dpi();
             inchesWidth = size.width() / dpi.width();
             inchesHeight = size.height() / dpi.height();
         }
         break;
 
         case Generator::None:
         break;
     }
     if (QLocale::system().measurementSystem() == QLocale::ImperialSystem)
     {
         return i18nc("%1 is width, %2 is height, %3 is paper size name", "%1 x %2 in (%3)", inchesWidth, inchesHeight, namePaperSize(inchesWidth, inchesHeight));
     }
     else
     {
         return i18nc("%1 is width, %2 is height, %3 is paper size name", "%1 x %2 mm (%3)", QString::number(inchesWidth * 25.4, 'd', 0), QString::number(inchesHeight * 25.4, 'd', 0), namePaperSize(inchesWidth, inchesHeight));
     }
 }
 
 qulonglong DocumentPrivate::calculateMemoryToFree()
 {
     // [MEM] choose memory parameters based on configuration profile
     qulonglong clipValue = 0;
     qulonglong memoryToFree = 0;
 
     switch ( SettingsCore::memoryLevel() )
     {
         case SettingsCore::EnumMemoryLevel::Low:
             memoryToFree = m_allocatedPixmapsTotalMemory;
             break;
 
         case SettingsCore::EnumMemoryLevel::Normal:
         {
             qulonglong thirdTotalMemory = getTotalMemory() / 3;
             qulonglong freeMemory = getFreeMemory();
             if (m_allocatedPixmapsTotalMemory > thirdTotalMemory) memoryToFree = m_allocatedPixmapsTotalMemory - thirdTotalMemory;
             if (m_allocatedPixmapsTotalMemory > freeMemory) clipValue = (m_allocatedPixmapsTotalMemory - freeMemory) / 2;
         }
         break;
 
         case SettingsCore::EnumMemoryLevel::Aggressive:
         {
             qulonglong freeMemory = getFreeMemory();
             if (m_allocatedPixmapsTotalMemory > freeMemory) clipValue = (m_allocatedPixmapsTotalMemory - freeMemory) / 2;
         }
         break;
         case SettingsCore::EnumMemoryLevel::Greedy:
         {
             qulonglong freeSwap;
             qulonglong freeMemory = getFreeMemory( &freeSwap );
             const qulonglong memoryLimit = qMin( qMax( freeMemory, getTotalMemory()/2 ), freeMemory+freeSwap );
             if (m_allocatedPixmapsTotalMemory > memoryLimit) clipValue = (m_allocatedPixmapsTotalMemory - memoryLimit) / 2;
         }
         break;
     }
 
     if ( clipValue > memoryToFree )
         memoryToFree = clipValue;
 
     return memoryToFree;
 }
 
 void DocumentPrivate::cleanupPixmapMemory()
 {
     cleanupPixmapMemory( calculateMemoryToFree() );
 }
 
 void DocumentPrivate::cleanupPixmapMemory( qulonglong memoryToFree )
 {
     if ( memoryToFree < 1 )
         return;
 
     const int currentViewportPage = (*m_viewportIterator).pageNumber;
 
     // Create a QMap of visible rects, indexed by page number
     QMap< int, VisiblePageRect * > visibleRects;
     QVector< Okular::VisiblePageRect * >::const_iterator vIt = m_pageRects.constBegin(), vEnd = m_pageRects.constEnd();
     for ( ; vIt != vEnd; ++vIt )
         visibleRects.insert( (*vIt)->pageNumber, (*vIt) );
 
     // Free memory starting from pages that are farthest from the current one
     int pagesFreed = 0;
     while ( memoryToFree > 0 )
     {
         AllocatedPixmap * p = searchLowestPriorityPixmap( true, true );
         if ( !p ) // No pixmap to remove
             break;
 
         qCDebug(OkularCoreDebug).nospace() << "Evicting cache pixmap observer=" << p->observer << " page=" << p->page;
 
         // m_allocatedPixmapsTotalMemory can't underflow because we always add or remove
         // the memory used by the AllocatedPixmap so at most it can reach zero
         m_allocatedPixmapsTotalMemory -= p->memory;
         // Make sure memoryToFree does not underflow
         if ( p->memory > memoryToFree )
             memoryToFree = 0;
         else
             memoryToFree -= p->memory;
         pagesFreed++;
         // delete pixmap
         m_pagesVector.at( p->page )->deletePixmap( p->observer );
         // delete allocation descriptor
         delete p;
     }
 
     // If we're still on low memory, try to free individual tiles
 
     // Store pages that weren't completely removed
 
     QLinkedList< AllocatedPixmap * > pixmapsToKeep;
     while (memoryToFree > 0)
     {
         int clean_hits = 0;
         foreach (DocumentObserver *observer, m_observers)
         {
             AllocatedPixmap * p = searchLowestPriorityPixmap( false, true, observer );
             if ( !p ) // No pixmap to remove
                 continue;
 
             clean_hits++;
 
             TilesManager *tilesManager = m_pagesVector.at( p->page )->d->tilesManager( observer );
             if ( tilesManager && tilesManager->totalMemory() > 0 )
             {
                 qulonglong memoryDiff = p->memory;
                 NormalizedRect visibleRect;
                 if ( visibleRects.contains( p->page ) )
                     visibleRect = visibleRects[ p->page ]->rect;
 
                 // Free non visible tiles
                 tilesManager->cleanupPixmapMemory( memoryToFree, visibleRect, currentViewportPage );
 
                 p->memory = tilesManager->totalMemory();
                 memoryDiff -= p->memory;
                 memoryToFree = (memoryDiff < memoryToFree) ? (memoryToFree - memoryDiff) : 0;
                 m_allocatedPixmapsTotalMemory -= memoryDiff;
 
                 if ( p->memory > 0 )
                     pixmapsToKeep.append( p );
                 else
                     delete p;
             }
             else
                 pixmapsToKeep.append( p );
         }
 
         if (clean_hits == 0) break;
     }
 
     m_allocatedPixmaps += pixmapsToKeep;
     //p--rintf("freeMemory A:[%d -%d = %d] \n", m_allocatedPixmaps.count() + pagesFreed, pagesFreed, m_allocatedPixmaps.count() );
 }
 
 /* Returns the next pixmap to evict from cache, or NULL if no suitable pixmap
  * if found. If unloadableOnly is set, only unloadable pixmaps are returned. If
  * thenRemoveIt is set, the pixmap is removed from m_allocatedPixmaps before
  * returning it
  */
 AllocatedPixmap * DocumentPrivate::searchLowestPriorityPixmap( bool unloadableOnly, bool thenRemoveIt, DocumentObserver *observer )
 {
     QLinkedList< AllocatedPixmap * >::iterator pIt = m_allocatedPixmaps.begin();
     QLinkedList< AllocatedPixmap * >::iterator pEnd = m_allocatedPixmaps.end();
     QLinkedList< AllocatedPixmap * >::iterator farthestPixmap = pEnd;
     const int currentViewportPage = (*m_viewportIterator).pageNumber;
 
     /* Find the pixmap that is farthest from the current viewport */
     int maxDistance = -1;
     while ( pIt != pEnd )
     {
         const AllocatedPixmap * p = *pIt;
         // Filter by observer
         if ( observer == 0 || p->observer == observer )
         {
             const int distance = qAbs( p->page - currentViewportPage );
             if ( maxDistance < distance && ( !unloadableOnly || p->observer->canUnloadPixmap( p->page ) ) )
             {
                 maxDistance = distance;
                 farthestPixmap = pIt;
             }
         }
         ++pIt;
     }
 
     /* No pixmap to remove */
     if ( farthestPixmap == pEnd )
         return 0;
 
     AllocatedPixmap * selectedPixmap = *farthestPixmap;
     if ( thenRemoveIt )
         m_allocatedPixmaps.erase( farthestPixmap );
     return selectedPixmap;
 }
 
 qulonglong DocumentPrivate::getTotalMemory()
 {
     static qulonglong cachedValue = 0;
     if ( cachedValue )
         return cachedValue;
 
 #if defined(Q_OS_LINUX)
     // if /proc/meminfo doesn't exist, return 128MB
     QFile memFile( QStringLiteral("/proc/meminfo") );
     if ( !memFile.open( QIODevice::ReadOnly ) )
         return (cachedValue = 134217728);
 
     QTextStream readStream( &memFile );
     while ( true )
     {
         QString entry = readStream.readLine();
         if ( entry.isNull() ) break;
         if ( entry.startsWith( QLatin1String("MemTotal:") ) )
             return (cachedValue = (Q_UINT64_C(1024) * entry.section( QLatin1Char ( ' ' ), -2, -2 ).toULongLong()));
     }
 #elif defined(Q_OS_FREEBSD)
     qulonglong physmem;
     int mib[] = {CTL_HW, HW_PHYSMEM};
     size_t len = sizeof( physmem );
     if ( sysctl( mib, 2, &physmem, &len, NULL, 0 ) == 0 )
         return (cachedValue = physmem);
 #elif defined(Q_OS_WIN)
     MEMORYSTATUSEX stat;
     stat.dwLength = sizeof(stat);
     GlobalMemoryStatusEx (&stat);
 
     return ( cachedValue = stat.ullTotalPhys );
 #endif
     return (cachedValue = 134217728);
 }
 
 qulonglong DocumentPrivate::getFreeMemory( qulonglong *freeSwap )
 {
     static QTime lastUpdate = QTime::currentTime().addSecs(-3);
     static qulonglong cachedValue = 0;
     static qulonglong cachedFreeSwap = 0;
 
     if ( qAbs( lastUpdate.secsTo( QTime::currentTime() ) ) <= 2 )
     {
         if (freeSwap)
             *freeSwap = cachedFreeSwap;
         return cachedValue;
     }
 
     /* Initialize the returned free swap value to 0. It is overwritten if the
      * actual value is available */
     if (freeSwap)
         *freeSwap = 0;
 
 #if defined(Q_OS_LINUX)
     // if /proc/meminfo doesn't exist, return MEMORY FULL
     QFile memFile( QStringLiteral("/proc/meminfo") );
     if ( !memFile.open( QIODevice::ReadOnly ) )
         return 0;
 
     // read /proc/meminfo and sum up the contents of 'MemFree', 'Buffers'
     // and 'Cached' fields. consider swapped memory as used memory.
     qulonglong memoryFree = 0;
     QString entry;
     QTextStream readStream( &memFile );
     static const int nElems = 5;
     QString names[nElems] = { QStringLiteral("MemFree:"), QStringLiteral("Buffers:"), QStringLiteral("Cached:"), QStringLiteral("SwapFree:"), QStringLiteral("SwapTotal:") };
     qulonglong values[nElems] = { 0, 0, 0, 0, 0 };
     bool foundValues[nElems] = { false, false, false, false, false };
     while ( true )
     {
         entry = readStream.readLine();
         if ( entry.isNull() ) break;
         for ( int i = 0; i < nElems; ++i )
         {
             if ( entry.startsWith( names[i] ) )
             {
                 values[i] = entry.section( QLatin1Char ( ' ' ), -2, -2 ).toULongLong( &foundValues[i] );
             }
         }
     }
     memFile.close();
     bool found = true;
     for ( int i = 0; found && i < nElems; ++i )
         found = found && foundValues[i];
     if ( found )
     {
         /* MemFree + Buffers + Cached - SwapUsed =
          * = MemFree + Buffers + Cached - (SwapTotal - SwapFree) =
          * = MemFree + Buffers + Cached + SwapFree - SwapTotal */
         memoryFree = values[0] + values[1] + values[2] + values[3];
         if ( values[4] > memoryFree )
             memoryFree = 0;
         else
             memoryFree -= values[4];
     }
     else
     {
         return 0;
     }
 
     lastUpdate = QTime::currentTime();
 
     if (freeSwap)
         *freeSwap = ( cachedFreeSwap = (Q_UINT64_C(1024) * values[3]) );
     return ( cachedValue = (Q_UINT64_C(1024) * memoryFree) );
 #elif defined(Q_OS_FREEBSD)
     qulonglong cache, inact, free, psize;
     size_t cachelen, inactlen, freelen, psizelen;
     cachelen = sizeof( cache );
     inactlen = sizeof( inact );
     freelen = sizeof( free );
     psizelen = sizeof( psize );
     // sum up inactive, cached and free memory
     if ( sysctlbyname( "vm.stats.vm.v_cache_count", &cache, &cachelen, NULL, 0 ) == 0 &&
             sysctlbyname( "vm.stats.vm.v_inactive_count", &inact, &inactlen, NULL, 0 ) == 0 &&
             sysctlbyname( "vm.stats.vm.v_free_count", &free, &freelen, NULL, 0 ) == 0 &&
             sysctlbyname( "vm.stats.vm.v_page_size", &psize, &psizelen, NULL, 0 ) == 0 )
     {
         lastUpdate = QTime::currentTime();
         return (cachedValue = (cache + inact + free) * psize);
     }
     else
     {
         return 0;
     }
 #elif defined(Q_OS_WIN)
     MEMORYSTATUSEX stat;
     stat.dwLength = sizeof(stat);
     GlobalMemoryStatusEx (&stat);
 
     lastUpdate = QTime::currentTime();
 
     if (freeSwap)
         *freeSwap = ( cachedFreeSwap = stat.ullAvailPageFile );
     return ( cachedValue = stat.ullAvailPhys );
 #else
     // tell the memory is full.. will act as in LOW profile
     return 0;
 #endif
 }
 
 void DocumentPrivate::loadDocumentInfo()
 // note: load data and stores it internally (document or pages). observers
 // are still uninitialized at this point so don't access them
 {
     //qCDebug(OkularCoreDebug).nospace() << "Using '" << d->m_xmlFileName << "' as document info file.";
     if ( m_xmlFileName.isEmpty() )
         return;
 
     QFile infoFile( m_xmlFileName );
     loadDocumentInfo( infoFile );
 }
 
 void DocumentPrivate::loadDocumentInfo( QFile &infoFile )
 {
     if ( !infoFile.exists() || !infoFile.open( QIODevice::ReadOnly ) )
         return;
 
     // Load DOM from XML file
     QDomDocument doc( QStringLiteral("documentInfo") );
     if ( !doc.setContent( &infoFile ) )
     {
         qCDebug(OkularCoreDebug) << "Can't load XML pair! Check for broken xml.";
         infoFile.close();
         return;
     }
     infoFile.close();
 
     QDomElement root = doc.documentElement();
     if ( root.tagName() != QLatin1String("documentInfo") )
         return;
 
     // Parse the DOM tree
     QDomNode topLevelNode = root.firstChild();
     while ( topLevelNode.isElement() )
     {
         QString catName = topLevelNode.toElement().tagName();
 
         // Restore page attributes (bookmark, annotations, ...) from the DOM
         if ( catName == QLatin1String("pageList") )
         {
             QDomNode pageNode = topLevelNode.firstChild();
             while ( pageNode.isElement() )
             {
                 QDomElement pageElement = pageNode.toElement();
                 if ( pageElement.hasAttribute( QStringLiteral("number") ) )
                 {
                     // get page number (node's attribute)
                     bool ok;
                     int pageNumber = pageElement.attribute( QStringLiteral("number") ).toInt( &ok );
 
                     // pass the domElement to the right page, to read config data from
                     if ( ok && pageNumber >= 0 && pageNumber < (int)m_pagesVector.count() )
                         m_pagesVector[ pageNumber ]->d->restoreLocalContents( pageElement );
                 }
                 pageNode = pageNode.nextSibling();
             }
         }
 
         // Restore 'general info' from the DOM
         else if ( catName == QLatin1String("generalInfo") )
         {
             QDomNode infoNode = topLevelNode.firstChild();
             while ( infoNode.isElement() )
             {
                 QDomElement infoElement = infoNode.toElement();
 
                 // restore viewports history
                 if ( infoElement.tagName() == QLatin1String("history") )
                 {
                     // clear history
                     m_viewportHistory.clear();
                     // append old viewports
                     QDomNode historyNode = infoNode.firstChild();
                     while ( historyNode.isElement() )
                     {
                         QDomElement historyElement = historyNode.toElement();
                         if ( historyElement.hasAttribute( QStringLiteral("viewport") ) )
                         {
                             QString vpString = historyElement.attribute( QStringLiteral("viewport") );
                             m_viewportIterator = m_viewportHistory.insert( m_viewportHistory.end(),
                                     DocumentViewport( vpString ) );
                         }
                         historyNode = historyNode.nextSibling();
                     }
                     // consistancy check
                     if ( m_viewportHistory.isEmpty() )
                         m_viewportIterator = m_viewportHistory.insert( m_viewportHistory.end(), DocumentViewport() );
                 }
                 else if ( infoElement.tagName() == QLatin1String("rotation") )
                 {
                     QString str = infoElement.text();
                     bool ok = true;
                     int newrotation = !str.isEmpty() ? ( str.toInt( &ok ) % 4 ) : 0;
                     if ( ok && newrotation != 0 )
                     {
                         setRotationInternal( newrotation, false );
                     }
                 }
                 else if ( infoElement.tagName() == QLatin1String("views") )
                 {
                     QDomNode viewNode = infoNode.firstChild();
                     while ( viewNode.isElement() )
                     {
                         QDomElement viewElement = viewNode.toElement();
                         if ( viewElement.tagName() == QLatin1String("view") )
                         {
                             const QString viewName = viewElement.attribute( QStringLiteral("name") );
                             Q_FOREACH ( View * view, m_views )
                             {
                                 if ( view->name() == viewName )
                                 {
                                     loadViewsInfo( view, viewElement );
                                     break;
                                 }
                             }
                         }
                         viewNode = viewNode.nextSibling();
                     }
                 }
                 infoNode = infoNode.nextSibling();
             }
         }
 
         topLevelNode = topLevelNode.nextSibling();
     } // </documentInfo>
 }
 
 void DocumentPrivate::loadViewsInfo( View *view, const QDomElement &e )
 {
     QDomNode viewNode = e.firstChild();
     while ( viewNode.isElement() )
     {
         QDomElement viewElement = viewNode.toElement();
 
         if ( viewElement.tagName() == QLatin1String("zoom") )
         {
             const QString valueString = viewElement.attribute( QStringLiteral("value") );
             bool newzoom_ok = true;
             const double newzoom = !valueString.isEmpty() ? valueString.toDouble( &newzoom_ok ) : 1.0;
             if ( newzoom_ok && newzoom != 0
                  && view->supportsCapability( View::Zoom )
                  && ( view->capabilityFlags( View::Zoom ) & ( View::CapabilityRead | View::CapabilitySerializable ) ) )
             {
                 view->setCapability( View::Zoom, newzoom );
             }
             const QString modeString = viewElement.attribute( QStringLiteral("mode") );
             bool newmode_ok = true;
             const int newmode = !modeString.isEmpty() ? modeString.toInt( &newmode_ok ) : 2;
             if ( newmode_ok
                  && view->supportsCapability( View::ZoomModality )
                  && ( view->capabilityFlags( View::ZoomModality ) & ( View::CapabilityRead | View::CapabilitySerializable ) ) )
             {
                 view->setCapability( View::ZoomModality, newmode );
             }
         }
 
         viewNode = viewNode.nextSibling();
     }
 }
 
 void DocumentPrivate::saveViewsInfo( View *view, QDomElement &e ) const
 {
     if ( view->supportsCapability( View::Zoom )
          && ( view->capabilityFlags( View::Zoom ) & ( View::CapabilityRead | View::CapabilitySerializable ) )
          && view->supportsCapability( View::ZoomModality )
          && ( view->capabilityFlags( View::ZoomModality ) & ( View::CapabilityRead | View::CapabilitySerializable ) ) )
     {
         QDomElement zoomEl = e.ownerDocument().createElement( QStringLiteral("zoom") );
         e.appendChild( zoomEl );
         bool ok = true;
         const double zoom = view->capability( View::Zoom ).toDouble( &ok );
         if ( ok && zoom != 0 )
         {
             zoomEl.setAttribute( QStringLiteral("value"), QString::number(zoom) );
         }
         const int mode = view->capability( View::ZoomModality ).toInt( &ok );
         if ( ok )
         {
             zoomEl.setAttribute( QStringLiteral("mode"), mode );
         }
     }
 }
 
 QUrl DocumentPrivate::giveAbsoluteUrl( const QString & fileName ) const
 {
     if ( !QDir::isRelativePath( fileName ) )
         return QUrl::fromLocalFile(fileName);
 
     if ( !m_url.isValid() )
         return QUrl();
 
     return QUrl(KIO::upUrl(m_url).toString() + fileName);
 }
 
 bool DocumentPrivate::openRelativeFile( const QString & fileName )
 {
     QUrl url = giveAbsoluteUrl( fileName );
     if ( url.isEmpty() )
         return false;
 
     qCDebug(OkularCoreDebug).nospace() << "openRelativeFile: '" << url << "'";
 
     emit m_parent->openUrl( url );
     return true;
 }
 
 Generator * DocumentPrivate::loadGeneratorLibrary( const KPluginMetaData &service )
 {
     KPluginLoader loader( service.fileName() );
     qCDebug(OkularCoreDebug) << service.fileName();
     KPluginFactory *factory = loader.factory();
     if ( !factory )
     {
         qCWarning(OkularCoreDebug).nospace() << "Invalid plugin factory for " << service.fileName() << ":" << loader.errorString();
         return 0;
     }
 
     Generator * plugin = factory->create<Okular::Generator>();
 
     GeneratorInfo info( plugin, service );
     m_loadedGenerators.insert( service.pluginId(), info );
     return plugin;
 }
 
 void DocumentPrivate::loadAllGeneratorLibraries()
 {
     if ( m_generatorsLoaded )
         return;
 
     loadServiceList( availableGenerators() );
 
     m_generatorsLoaded = true;
 }
 
 void DocumentPrivate::loadServiceList( const QVector<KPluginMetaData>& offers )
 {
     int count = offers.count();
     if ( count <= 0 )
         return;
 
     for ( int i = 0; i < count; ++i )
     {
         QString id = offers.at(i).pluginId();
         // don't load already loaded generators
         QHash< QString, GeneratorInfo >::const_iterator genIt = m_loadedGenerators.constFind( id );
         if ( !m_loadedGenerators.isEmpty() && genIt != m_loadedGenerators.constEnd() )
             continue;
 
         Generator * g = loadGeneratorLibrary( offers.at(i) );
         (void)g;
     }
 }
 
 void DocumentPrivate::unloadGenerator( const GeneratorInfo& info )
 {
     delete info.generator;
 }
 
 void DocumentPrivate::cacheExportFormats()
 {
     if ( m_exportCached )
         return;
 
     const ExportFormat::List formats = m_generator->exportFormats();
     for ( int i = 0; i < formats.count(); ++i )
     {
         if ( formats.at( i ).mimeType().name() == QLatin1String( "text/plain" ) )
             m_exportToText = formats.at( i );
         else
             m_exportFormats.append( formats.at( i ) );
     }
 
     m_exportCached = true;
 }
 
 ConfigInterface* DocumentPrivate::generatorConfig( GeneratorInfo& info )
 {
     if ( info.configChecked )
         return info.config;
 
     info.config = qobject_cast< Okular::ConfigInterface * >( info.generator );
     info.configChecked = true;
     return info.config;
 }
 
 SaveInterface* DocumentPrivate::generatorSave( GeneratorInfo& info )
 {
     if ( info.saveChecked )
         return info.save;
 
     info.save = qobject_cast< Okular::SaveInterface * >( info.generator );
     info.saveChecked = true;
     return info.save;
 }
 
 Document::OpenResult DocumentPrivate::openDocumentInternal( const KPluginMetaData& offer, bool isstdin, const QString& docFile, const QByteArray& filedata, const QString& password )
 {
     QString propName = offer.pluginId();
     QHash< QString, GeneratorInfo >::const_iterator genIt = m_loadedGenerators.constFind( propName );
     m_walletGenerator = 0;
     if ( genIt != m_loadedGenerators.constEnd() )
     {
         m_generator = genIt.value().generator;
     }
     else
     {
         m_generator = loadGeneratorLibrary( offer );
         if ( !m_generator )
             return Document::OpenError;
         genIt = m_loadedGenerators.constFind( propName );
         Q_ASSERT( genIt != m_loadedGenerators.constEnd() );
     }
     Q_ASSERT_X( m_generator, "Document::load()", "null generator?!" );
 
     m_generator->d_func()->m_document = this;
 
     // connect error reporting signals
     QObject::connect( m_generator, &Generator::error, m_parent, &Document::error );
     QObject::connect( m_generator, &Generator::warning, m_parent, &Document::warning );
     QObject::connect( m_generator, &Generator::notice, m_parent, &Document::notice );
 
     QApplication::setOverrideCursor( Qt::WaitCursor );
 
     const QSizeF dpi = Utils::realDpi(m_widget);
     qCDebug(OkularCoreDebug) << "Output DPI:" << dpi;
     m_generator->setDPI(dpi);
 
     Document::OpenResult openResult = Document::OpenError;
     if ( !isstdin )
     {
         openResult = m_generator->loadDocumentWithPassword( docFile, m_pagesVector, password );
     }
     else if ( !filedata.isEmpty() )
     {
         if ( m_generator->hasFeature( Generator::ReadRawData ) )
         {
             openResult = m_generator->loadDocumentFromDataWithPassword( filedata, m_pagesVector, password );
         }
         else
         {
             m_tempFile = new QTemporaryFile();
             if ( !m_tempFile->open() )
             {
                 delete m_tempFile;
                 m_tempFile = 0;
             }
             else
             {
                 m_tempFile->write( filedata );
                 QString tmpFileName = m_tempFile->fileName();
                 m_tempFile->close();
                 openResult = m_generator->loadDocumentWithPassword( tmpFileName, m_pagesVector, password );
             }
         }
     }
 
     QApplication::restoreOverrideCursor();
     if ( openResult != Document::OpenSuccess || m_pagesVector.size() <= 0 )
     {
         m_generator->d_func()->m_document = 0;
         QObject::disconnect( m_generator, 0, m_parent, 0 );
         // TODO this is a bit of a hack, since basically means that
         // you can only call walletDataForFile after calling openDocument
         // but since in reality it's what happens I've decided not to refactor/break API
         // One solution is just kill walletDataForFile and make OpenResult be an object
         // where the wallet data is also returned when OpenNeedsPassword
         m_walletGenerator = m_generator;
         m_generator = 0;
 
         qDeleteAll( m_pagesVector );
         m_pagesVector.clear();
         delete m_tempFile;
         m_tempFile = 0;
 
         // TODO: emit a message telling the document is empty
         if ( openResult == Document::OpenSuccess )
             openResult = Document::OpenError;
     }
 
     return openResult;
 }
 
 bool DocumentPrivate::savePageDocumentInfo( QTemporaryFile *infoFile, int what ) const
 {
     if ( infoFile->open() )
     {
         // 1. Create DOM
         QDomDocument doc( QStringLiteral("documentInfo") );
         QDomProcessingInstruction xmlPi = doc.createProcessingInstruction(
                 QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"utf-8\"" ) );
         doc.appendChild( xmlPi );
         QDomElement root = doc.createElement( QStringLiteral("documentInfo") );
         doc.appendChild( root );
 
         // 2.1. Save page attributes (bookmark state, annotations, ... ) to DOM
         QDomElement pageList = doc.createElement( QStringLiteral("pageList") );
         root.appendChild( pageList );
         // <page list><page number='x'>.... </page> save pages that hold data
         QVector< Page * >::const_iterator pIt = m_pagesVector.constBegin(), pEnd = m_pagesVector.constEnd();
         for ( ; pIt != pEnd; ++pIt )
             (*pIt)->d->saveLocalContents( pageList, doc, PageItems( what ) );
 
         // 3. Save DOM to XML file
         QString xml = doc.toString();
         QTextStream os( infoFile );
         os.setCodec( "UTF-8" );
         os << xml;
         return true;
     }
     return false;
 }
 
 DocumentViewport DocumentPrivate::nextDocumentViewport() const
 {
     DocumentViewport ret = m_nextDocumentViewport;
     if ( !m_nextDocumentDestination.isEmpty() && m_generator )
     {
         DocumentViewport vp( m_parent->metaData( QStringLiteral("NamedViewport"), m_nextDocumentDestination ).toString() );
         if ( vp.isValid() )
         {
             ret = vp;
         }
     }
     return ret;
 }
 
 void DocumentPrivate::warnLimitedAnnotSupport()
 {
     if ( !m_showWarningLimitedAnnotSupport )
         return;
     m_showWarningLimitedAnnotSupport = false; // Show the warning once
 
     if ( m_annotationsNeedSaveAs )
     {
         // Shown if the user is editing annotations in a file whose metadata is
         // not stored locally (.okular archives belong to this category)
         KMessageBox::information( m_widget, i18n("Your annotation changes will not be saved automatically. Use File -> Save As...\nor your changes will be lost once the document is closed"), QString(), QStringLiteral("annotNeedSaveAs") );
     }
     else if ( !canAddAnnotationsNatively() )
     {
         // If the generator doesn't support native annotations
         KMessageBox::information( m_widget, i18n("Your annotations are saved internally by Okular.\nYou can export the annotated document using File -> Export As -> Document Archive"), QString(), QStringLiteral("annotExportAsArchive") );
     }
 }
 
 void DocumentPrivate::performAddPageAnnotation( int page, Annotation * annotation )
 {
     Okular::SaveInterface * iface = qobject_cast< Okular::SaveInterface * >( m_generator );
     AnnotationProxy *proxy = iface ? iface->annotationProxy() : 0;
 
     // find out the page to attach annotation
     Page * kp = m_pagesVector[ page ];
     if ( !m_generator || !kp )
         return;
 
     // the annotation belongs already to a page
     if ( annotation->d_ptr->m_page )
         return;
 
     // add annotation to the page
     kp->addAnnotation( annotation );
 
     // tell the annotation proxy
     if ( proxy && proxy->supports(AnnotationProxy::Addition) )
         proxy->notifyAddition( annotation, page );
 
     // notify observers about the change
     notifyAnnotationChanges( page );
 
     if ( annotation->flags() & Annotation::ExternallyDrawn )
     {
         // Redraw everything, including ExternallyDrawn annotations
         refreshPixmaps( page );
     }
 
     warnLimitedAnnotSupport();
 }
 
 void DocumentPrivate::performRemovePageAnnotation( int page, Annotation * annotation )
 {
     Okular::SaveInterface * iface = qobject_cast< Okular::SaveInterface * >( m_generator );
     AnnotationProxy *proxy = iface ? iface->annotationProxy() : 0;
     bool isExternallyDrawn;
 
     // find out the page
     Page * kp = m_pagesVector[ page ];
     if ( !m_generator || !kp )
         return;
 
     if ( annotation->flags() & Annotation::ExternallyDrawn )
         isExternallyDrawn = true;
     else
         isExternallyDrawn = false;
 
     // try to remove the annotation
     if ( m_parent->canRemovePageAnnotation( annotation ) )
     {
         // tell the annotation proxy
         if ( proxy && proxy->supports(AnnotationProxy::Removal) )
             proxy->notifyRemoval( annotation, page );
 
         kp->removeAnnotation( annotation ); // Also destroys the object
 
         // in case of success, notify observers about the change
         notifyAnnotationChanges( page );
 
         if ( isExternallyDrawn )
         {
             // Redraw everything, including ExternallyDrawn annotations
             refreshPixmaps( page );
         }
     }
 
     warnLimitedAnnotSupport();
 }
 
 void DocumentPrivate::performModifyPageAnnotation( int page, Annotation * annotation, bool appearanceChanged )
 {
     Okular::SaveInterface * iface = qobject_cast< Okular::SaveInterface * >( m_generator );
     AnnotationProxy *proxy = iface ? iface->annotationProxy() : 0;
 
     // find out the page
     Page * kp = m_pagesVector[ page ];
     if ( !m_generator || !kp )
         return;
 
     // tell the annotation proxy
     if ( proxy && proxy->supports(AnnotationProxy::Modification) )
     {
         proxy->notifyModification( annotation, page, appearanceChanged );
     }
 
     // notify observers about the change
     notifyAnnotationChanges( page );
     if ( appearanceChanged && (annotation->flags() & Annotation::ExternallyDrawn) )
     {
         /* When an annotation is being moved, the generator will not render it.
          * Therefore there's no need to refresh pixmaps after the first time */
         if ( annotation->flags() & (Annotation::BeingMoved | Annotation::BeingResized) )
         {
             if ( m_annotationBeingModified )
                 return;
             else // First time: take note
                 m_annotationBeingModified = true;
         }
         else
         {
             m_annotationBeingModified = false;
         }
 
         // Redraw everything, including ExternallyDrawn annotations
         qCDebug(OkularCoreDebug) << "Refreshing Pixmaps";
         refreshPixmaps( page );
     }
 
     // If the user is moving or resizing the annotation, don't steal the focus
     if ( (annotation->flags() & (Annotation::BeingMoved | Annotation::BeingResized) ) == 0 )
         warnLimitedAnnotSupport();
 }
 
 void DocumentPrivate::performSetAnnotationContents( const QString & newContents, Annotation *annot, int pageNumber )
 {
     bool appearanceChanged = false;
 
     // Check if appearanceChanged should be true
     switch ( annot->subType() )
     {
         // If it's an in-place TextAnnotation, set the inplace text
         case Okular::Annotation::AText:
         {
             Okular::TextAnnotation * txtann = static_cast< Okular::TextAnnotation * >( annot );
             if ( txtann->textType() == Okular::TextAnnotation::InPlace )
             {
                 appearanceChanged = true;
             }
             break;
         }
         // If it's a LineAnnotation, check if caption text is visible
         case Okular::Annotation::ALine:
         {
             Okular::LineAnnotation * lineann = static_cast< Okular::LineAnnotation * >( annot );
             if ( lineann->showCaption() )
                 appearanceChanged = true;
             break;
         }
         default:
             break;
     }
 
     // Set contents
     annot->setContents( newContents );
 
     // Tell the document the annotation has been modified
     performModifyPageAnnotation( pageNumber,  annot, appearanceChanged );
 }
 
 void DocumentPrivate::recalculateForms()
 {
     const QVariant fco = m_parent->metaData(QLatin1String("FormCalculateOrder"));
     const QVector<int> formCalculateOrder = fco.value<QVector<int>>();
     foreach(int formId, formCalculateOrder) {
         for ( uint pageIdx = 0; pageIdx  < m_parent->pages(); pageIdx++ )
         {
             const Page *p = m_parent->page( pageIdx );
             if (p)
             {
                 foreach( FormField *form, p->formFields() )
                 {
                     if ( form->id() == formId ) {
                         Action *action = form->additionalAction( FormField::CalculateField );
                         if (action)
                         {
                             m_parent->processAction( action );
                         }
                         else
                         {
                             qWarning() << "Form that is part of calculate order doesn't have a calculate action";
                         }
                     }
                 }
             }
         }
     }
 }
 
 void DocumentPrivate::saveDocumentInfo() const
 {
     if ( m_xmlFileName.isEmpty() )
         return;
 
     QFile infoFile( m_xmlFileName );
     qCDebug(OkularCoreDebug) << "About to save document info to" << m_xmlFileName;
     if (!infoFile.open( QIODevice::WriteOnly | QIODevice::Truncate))
     {
         qCWarning(OkularCoreDebug) << "Failed to open docdata file" << m_xmlFileName;
         return;
 
     }
     // 1. Create DOM
     QDomDocument doc( QStringLiteral("documentInfo") );
     QDomProcessingInstruction xmlPi = doc.createProcessingInstruction(
             QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"utf-8\"" ) );
     doc.appendChild( xmlPi );
     QDomElement root = doc.createElement( QStringLiteral("documentInfo") );
     root.setAttribute( QStringLiteral("url"), m_url.toDisplayString(QUrl::PreferLocalFile) );
     doc.appendChild( root );
 
     // 2.1. Save page attributes (bookmark state, annotations, ... ) to DOM
     QDomElement pageList = doc.createElement( QStringLiteral("pageList") );
     root.appendChild( pageList );
     PageItems saveWhat = AllPageItems;
     if ( m_annotationsNeedSaveAs )
     {
         /* In this case, if the user makes a modification, he's requested to
             * save to a new document. Therefore, if there are existing local
             * annotations, we save them back unmodified in the original
             * document's metadata, so that it appears that it was not changed */
         saveWhat |= OriginalAnnotationPageItems;
     }
     // <page list><page number='x'>.... </page> save pages that hold data
     QVector< Page * >::const_iterator pIt = m_pagesVector.constBegin(), pEnd = m_pagesVector.constEnd();
     for ( ; pIt != pEnd; ++pIt )
         (*pIt)->d->saveLocalContents( pageList, doc, saveWhat );
 
     // 2.2. Save document info (current viewport, history, ... ) to DOM
     QDomElement generalInfo = doc.createElement( QStringLiteral("generalInfo") );
     root.appendChild( generalInfo );
     // create rotation node
     if ( m_rotation != Rotation0 )
     {
         QDomElement rotationNode = doc.createElement( QStringLiteral("rotation") );
         generalInfo.appendChild( rotationNode );
         rotationNode.appendChild( doc.createTextNode( QString::number( (int)m_rotation ) ) );
     }
     // <general info><history> ... </history> save history up to OKULAR_HISTORY_SAVEDSTEPS viewports
     QLinkedList< DocumentViewport >::const_iterator backIterator = m_viewportIterator;
     if ( backIterator != m_viewportHistory.constEnd() )
     {
         // go back up to OKULAR_HISTORY_SAVEDSTEPS steps from the current viewportIterator
         int backSteps = OKULAR_HISTORY_SAVEDSTEPS;
         while ( backSteps-- && backIterator != m_viewportHistory.constBegin() )
             --backIterator;
 
         // create history root node
         QDomElement historyNode = doc.createElement( QStringLiteral("history") );
         generalInfo.appendChild( historyNode );
 
         // add old[backIterator] and present[viewportIterator] items
         QLinkedList< DocumentViewport >::const_iterator endIt = m_viewportIterator;
         ++endIt;
         while ( backIterator != endIt )
         {
             QString name = (backIterator == m_viewportIterator) ? QStringLiteral ("current") : QStringLiteral ("oldPage");
             QDomElement historyEntry = doc.createElement( name );
             historyEntry.setAttribute( QStringLiteral("viewport"), (*backIterator).toString() );
             historyNode.appendChild( historyEntry );
             ++backIterator;
         }
     }
     // create views root node
     QDomElement viewsNode = doc.createElement( QStringLiteral("views") );
     generalInfo.appendChild( viewsNode );
     Q_FOREACH ( View * view, m_views )
     {
         QDomElement viewEntry = doc.createElement( QStringLiteral("view") );
         viewEntry.setAttribute( QStringLiteral("name"), view->name() );
         viewsNode.appendChild( viewEntry );
         saveViewsInfo( view, viewEntry );
     }
 
     // 3. Save DOM to XML file
     QString xml = doc.toString();
     QTextStream os( &infoFile );
     os.setCodec( "UTF-8" );
     os << xml;
     infoFile.close();
 }
 
 void DocumentPrivate::slotTimedMemoryCheck()
 {
     // [MEM] clean memory (for 'free mem dependant' profiles only)
     if ( SettingsCore::memoryLevel() != SettingsCore::EnumMemoryLevel::Low &&
          m_allocatedPixmapsTotalMemory > 1024*1024 )
         cleanupPixmapMemory();
 }
 
 void DocumentPrivate::sendGeneratorPixmapRequest()
 {
     /* If the pixmap cache will have to be cleaned in order to make room for the
      * next request, get the distance from the current viewport of the page
      * whose pixmap will be removed. We will ignore preload requests for pages
      * that are at the same distance or farther */
     const qulonglong memoryToFree = calculateMemoryToFree();
     const int currentViewportPage = (*m_viewportIterator).pageNumber;
     int maxDistance = INT_MAX; // Default: No maximum
     if ( memoryToFree )
     {
         AllocatedPixmap *pixmapToReplace = searchLowestPriorityPixmap( true );
         if ( pixmapToReplace )
             maxDistance = qAbs( pixmapToReplace->page - currentViewportPage );
     }
 
     // find a request
     PixmapRequest * request = 0;
     m_pixmapRequestsMutex.lock();
     while ( !m_pixmapRequestsStack.isEmpty() && !request )
     {
         PixmapRequest * r = m_pixmapRequestsStack.last();
         if (!r)
         {
             m_pixmapRequestsStack.pop_back();
             continue;
         }
 
         QRect requestRect = r->isTile() ? r->normalizedRect().geometry( r->width(), r->height() ) : QRect( 0, 0, r->width(), r->height() );
         TilesManager *tilesManager = r->d->tilesManager();
 
         // If it's a preload but the generator is not threaded no point in trying to preload
         if ( r->preload() && !m_generator->hasFeature( Generator::Threaded ) )
         {
             m_pixmapRequestsStack.pop_back();
             delete r;
         }
         // request only if page isn't already present and request has valid id
         // request only if page isn't already present and request has valid id
         else if ( ( !r->d->mForce && r->page()->hasPixmap( r->observer(), r->width(), r->height(), r->normalizedRect() ) ) || !m_observers.contains(r->observer()) )
         {
             m_pixmapRequestsStack.pop_back();
             delete r;
         }
         else if ( !r->d->mForce && r->preload() && qAbs( r->pageNumber() - currentViewportPage ) >= maxDistance )
         {
             m_pixmapRequestsStack.pop_back();
             //qCDebug(OkularCoreDebug) << "Ignoring request that doesn't fit in cache";
             delete r;
         }
         // Ignore requests for pixmaps that are already being generated
         else if ( tilesManager && tilesManager->isRequesting( r->normalizedRect(), r->width(), r->height() ) )
         {
             m_pixmapRequestsStack.pop_back();
             delete r;
         }
         // If the requested area is above 8000000 pixels, switch on the tile manager
         else if ( !tilesManager && m_generator->hasFeature( Generator::TiledRendering ) && (long)r->width() * (long)r->height() > 8000000L )
         {
             // if the image is too big. start using tiles
             qCDebug(OkularCoreDebug).nospace() << "Start using tiles on page " << r->pageNumber()
                 << " (" << r->width() << "x" << r->height() << " px);";
 
             // fill the tiles manager with the last rendered pixmap
-            const QPixmap *pixmap = r->page()->_o_nearestPixmap( r->observer(), r->width(), r->height(), r->devicePixelRatio() );
+            const QPixmap *pixmap = r->page()->_o_nearestPixmap( r->observer(), r->width(), r->height() );
             if ( pixmap )
             {
                 tilesManager = new TilesManager( r->pageNumber(), pixmap->width(), pixmap->height(), r->page()->rotation() );
                 tilesManager->setPixmap( pixmap, NormalizedRect( 0, 0, 1, 1 ) );
                 tilesManager->setSize( r->width(), r->height() );
             }
             else
             {
                 // create new tiles manager
                 tilesManager = new TilesManager( r->pageNumber(), r->width(), r->height(), r->page()->rotation() );
             }
             tilesManager->setRequest( r->normalizedRect(), r->width(), r->height() );
             r->page()->deletePixmap( r->observer() );
             r->page()->d->setTilesManager( r->observer(), tilesManager );
             r->setTile( true );
 
             // Change normalizedRect to the smallest rect that contains all
             // visible tiles.
             if ( !r->normalizedRect().isNull() )
             {
                 NormalizedRect tilesRect;
                 const QList<Tile> tiles = tilesManager->tilesAt( r->normalizedRect(), TilesManager::TerminalTile );
                 QList<Tile>::const_iterator tIt = tiles.constBegin(), tEnd = tiles.constEnd();
                 while ( tIt != tEnd )
                 {
                     Tile tile = *tIt;
                     if ( tilesRect.isNull() )
                         tilesRect = tile.rect();
                     else
                         tilesRect |= tile.rect();
 
                     ++tIt;
                 }
 
                 r->setNormalizedRect( tilesRect );
                 request = r;
             }
             else
             {
                 // Discard request if normalizedRect is null. This happens in
                 // preload requests issued by PageView if the requested page is
                 // not visible and the user has just switched from a non-tiled
                 // zoom level to a tiled one
                 m_pixmapRequestsStack.pop_back();
                 delete r;
             }
         }
         // If the requested area is below 6000000 pixels, switch off the tile manager
         else if ( tilesManager && (long)r->width() * (long)r->height() < 6000000L )
         {
             qCDebug(OkularCoreDebug).nospace() << "Stop using tiles on page " << r->pageNumber()
                 << " (" << r->width() << "x" << r->height() << " px);";
 
             // page is too small. stop using tiles.
             r->page()->deletePixmap( r->observer() );
             r->setTile( false );
 
             request = r;
         }
         else if ( (long)requestRect.width() * (long)requestRect.height() > 200000000L && (SettingsCore::memoryLevel() != SettingsCore::EnumMemoryLevel::Greedy ) )
         {
             m_pixmapRequestsStack.pop_back();
             if ( !m_warnedOutOfMemory )
             {
                 qCWarning(OkularCoreDebug).nospace() << "Running out of memory on page " << r->pageNumber()
                     << " (" << r->width() << "x" << r->height() << " px);";
                 qCWarning(OkularCoreDebug) << "this message will be reported only once.";
                 m_warnedOutOfMemory = true;
             }
             delete r;
         }
         else
         {
             request = r;
         }
     }
 
     // if no request found (or already generated), return
     if ( !request )
     {
         m_pixmapRequestsMutex.unlock();
         return;
     }
 
     // [MEM] preventive memory freeing
     qulonglong pixmapBytes = 0;
     TilesManager * tm = request->d->tilesManager();
     if ( tm )
         pixmapBytes = tm->totalMemory();
     else
         pixmapBytes = 4 * request->width() * request->height();
 
     if ( pixmapBytes > (1024 * 1024) )
         cleanupPixmapMemory( memoryToFree /* previously calculated value */ );
 
     // submit the request to the generator
     if ( m_generator->canGeneratePixmap() )
     {
         QRect requestRect = !request->isTile() ? QRect(0, 0, request->width(), request->height() ) : request->normalizedRect().geometry( request->width(), request->height() );
         qCDebug(OkularCoreDebug).nospace() << "sending request observer=" << request->observer() << " " <<requestRect.width() << "x" << requestRect.height() << "@" << request->pageNumber() << " async == " << request->asynchronous() << " isTile == " << request->isTile();
         m_pixmapRequestsStack.removeAll ( request );
 
         if ( tm )
             tm->setRequest( request->normalizedRect(), request->width(), request->height() );
 
         if ( (int)m_rotation % 2 )
             request->d->swap();
 
         if ( m_rotation != Rotation0 && !request->normalizedRect().isNull() )
             request->setNormalizedRect( TilesManager::fromRotatedRect(
                         request->normalizedRect(), m_rotation ) );
 
         // we always have to unlock _before_ the generatePixmap() because
         // a sync generation would end with requestDone() -> deadlock, and
         // we can not really know if the generator can do async requests
         m_executingPixmapRequests.push_back( request );
         m_pixmapRequestsMutex.unlock();
         m_generator->generatePixmap( request );
     }
     else
     {
         m_pixmapRequestsMutex.unlock();
         // pino (7/4/2006): set the polling interval from 10 to 30
         QTimer::singleShot( 30, m_parent, SLOT(sendGeneratorPixmapRequest()) );
     }
 }
 
 void DocumentPrivate::rotationFinished( int page, Okular::Page *okularPage )
 {
     Okular::Page *wantedPage = m_pagesVector.value( page, 0 );
     if ( !wantedPage || wantedPage != okularPage )
         return;
 
     foreach(DocumentObserver *o, m_observers)
         o->notifyPageChanged( page, DocumentObserver::Pixmap | DocumentObserver::Annotations );
 }
 
 void DocumentPrivate::slotFontReadingProgress( int page )
 {
     emit m_parent->fontReadingProgress( page );
 
     if ( page >= (int)m_parent->pages() - 1 )
     {
         emit m_parent->fontReadingEnded();
         m_fontThread = 0;
         m_fontsCached = true;
     }
 }
 
 void DocumentPrivate::fontReadingGotFont( const Okular::FontInfo& font )
 {
     // Try to avoid duplicate fonts
     if (m_fontsCache.indexOf(font) == -1) {
         m_fontsCache.append( font );
 
         emit m_parent->gotFont( font );
     }
 }
 
 void DocumentPrivate::slotGeneratorConfigChanged( const QString& )
 {
     if ( !m_generator )
         return;
 
     // reparse generator config and if something changed clear Pages
     bool configchanged = false;
     QHash< QString, GeneratorInfo >::iterator it = m_loadedGenerators.begin(), itEnd = m_loadedGenerators.end();
     for ( ; it != itEnd; ++it )
     {
         Okular::ConfigInterface * iface = generatorConfig( it.value() );
         if ( iface )
         {
             bool it_changed = iface->reparseConfig();
             if ( it_changed && ( m_generator == it.value().generator ) )
                 configchanged = true;
         }
     }
     if ( configchanged )
     {
         // invalidate pixmaps
         QVector<Page*>::const_iterator it = m_pagesVector.constBegin(), end = m_pagesVector.constEnd();
         for ( ; it != end; ++it ) {
             (*it)->deletePixmaps();
         }
 
         // [MEM] remove allocation descriptors
         qDeleteAll( m_allocatedPixmaps );
         m_allocatedPixmaps.clear();
         m_allocatedPixmapsTotalMemory = 0;
 
         // send reload signals to observers
         foreachObserverD( notifyContentsCleared( DocumentObserver::Pixmap ) );
     }
 
     // free memory if in 'low' profile
     if ( SettingsCore::memoryLevel() == SettingsCore::EnumMemoryLevel::Low &&
          !m_allocatedPixmaps.isEmpty() && !m_pagesVector.isEmpty() )
         cleanupPixmapMemory();
 }
 
 void DocumentPrivate::refreshPixmaps( int pageNumber )
 {
     Page* page = m_pagesVector.value( pageNumber, 0 );
     if ( !page )
         return;
 
     QLinkedList< Okular::PixmapRequest * > requestedPixmaps;
     QMap< DocumentObserver*, PagePrivate::PixmapObject >::ConstIterator it = page->d->m_pixmaps.constBegin(), itEnd = page->d->m_pixmaps.constEnd();
     for ( ; it != itEnd; ++it )
     {
         QSize size = (*it).m_pixmap->size();
-        qreal dpr = (*it).m_pixmap->devicePixelRatioF();
-
-        PixmapRequest * p = new PixmapRequest( it.key(), pageNumber, size.width(), size.height(), dpr, 1, PixmapRequest::Asynchronous );
+        PixmapRequest * p = new PixmapRequest( it.key(), pageNumber, size.width(), size.height(), 1, PixmapRequest::Asynchronous );
         p->d->mForce = true;
         requestedPixmaps.push_back( p );
     }
 
     foreach (DocumentObserver *observer, m_observers)
     {
         TilesManager *tilesManager = page->d->tilesManager( observer );
         if ( tilesManager )
         {
             tilesManager->markDirty();
 
-            PixmapRequest * p = new PixmapRequest( observer, pageNumber, tilesManager->width(), tilesManager->height(), tilesManager->devicePixelRatio(), 1, PixmapRequest::Asynchronous );
+            PixmapRequest * p = new PixmapRequest( observer, pageNumber, tilesManager->width(), tilesManager->height(), 1, PixmapRequest::Asynchronous );
 
             NormalizedRect tilesRect;
 
             // Get the visible page rect
             NormalizedRect visibleRect;
             QVector< Okular::VisiblePageRect * >::const_iterator vIt = m_pageRects.constBegin(), vEnd = m_pageRects.constEnd();
             for ( ; vIt != vEnd; ++vIt )
             {
                 if ( (*vIt)->pageNumber == pageNumber )
                 {
                     visibleRect = (*vIt)->rect;
                     break;
                 }
             }
 
             if ( !visibleRect.isNull() )
             {
                 p->setNormalizedRect( visibleRect );
                 p->setTile( true );
                 p->d->mForce = true;
                 requestedPixmaps.push_back( p );
             }
             else
             {
                 delete p;
             }
         }
     }
 
     if ( !requestedPixmaps.isEmpty() )
         m_parent->requestPixmaps( requestedPixmaps, Okular::Document::NoOption );
 }
 
 void DocumentPrivate::_o_configChanged()
 {
     // free text pages if needed
     calculateMaxTextPages();
     while (m_allocatedTextPagesFifo.count() > m_maxAllocatedTextPages)
     {
         int pageToKick = m_allocatedTextPagesFifo.takeFirst();
         m_pagesVector.at(pageToKick)->setTextPage( 0 ); // deletes the textpage
     }
 }
 
 void DocumentPrivate::doContinueDirectionMatchSearch(void *doContinueDirectionMatchSearchStruct)
 {
     DoContinueDirectionMatchSearchStruct *searchStruct = static_cast<DoContinueDirectionMatchSearchStruct *>(doContinueDirectionMatchSearchStruct);
     RunningSearch *search = m_searches.value(searchStruct->searchID);
 
     if ((m_searchCancelled && !searchStruct->match) || !search)
     {
         // if the user cancelled but he just got a match, give him the match!
         QApplication::restoreOverrideCursor();
 
         if (search) search->isCurrentlySearching = false;
 
         emit m_parent->searchFinished( searchStruct->searchID, Document::SearchCancelled );
         delete searchStruct->pagesToNotify;
         delete searchStruct;
         return;
     }
 
     const bool forward = search->cachedType == Document::NextMatch;
     bool doContinue = false;
     // if no match found, loop through the whole doc, starting from currentPage
     if ( !searchStruct->match )
     {
         const int pageCount = m_pagesVector.count();
         if (search->pagesDone < pageCount)
         {
             doContinue = true;
             if ( searchStruct->currentPage >= pageCount || searchStruct->currentPage < 0 )
             {
                 doContinue = false;
                 search->isCurrentlySearching = false;
                 search->continueOnPage = forward ? 0 : pageCount - 1;
                 search->continueOnMatch = RegularAreaRect();
                 emit m_parent->searchFinished ( searchStruct->searchID, Document::EndOfDocumentReached );
             }
         }
     }
 
     if (doContinue)
     {
         // get page
         Page * page = m_pagesVector[ searchStruct->currentPage ];
         // request search page if needed
         if ( !page->hasTextPage() )
             m_parent->requestTextPage( page->number() );
 
         // if found a match on the current page, end the loop
         searchStruct->match = page->findText( searchStruct->searchID, search->cachedString, forward ? FromTop : FromBottom, search->cachedCaseSensitivity );
         if ( !searchStruct->match )
         {
             if (forward) searchStruct->currentPage++;
             else searchStruct->currentPage--;
             search->pagesDone++;
         }
         else
         {
             search->pagesDone = 1;
         }
 
         // Both of the previous if branches need to call doContinueDirectionMatchSearch
         QMetaObject::invokeMethod(m_parent, "doContinueDirectionMatchSearch", Qt::QueuedConnection, Q_ARG(void *, searchStruct));
     }
     else
     {
         doProcessSearchMatch( searchStruct->match, search, searchStruct->pagesToNotify, searchStruct->currentPage, searchStruct->searchID, search->cachedViewportMove, search->cachedColor );
         delete searchStruct;
     }
 }
 
 void DocumentPrivate::doProcessSearchMatch( RegularAreaRect *match, RunningSearch *search, QSet< int > *pagesToNotify, int currentPage, int searchID, bool moveViewport, const QColor & color )
 {
     // reset cursor to previous shape
     QApplication::restoreOverrideCursor();
 
     bool foundAMatch = false;
 
     search->isCurrentlySearching = false;
 
     // if a match has been found..
     if ( match )
     {
         // update the RunningSearch structure adding this match..
         foundAMatch = true;
         search->continueOnPage = currentPage;
         search->continueOnMatch = *match;
         search->highlightedPages.insert( currentPage );
         // ..add highlight to the page..
         m_pagesVector[ currentPage ]->d->setHighlight( searchID, match, color );
 
         // ..queue page for notifying changes..
         pagesToNotify->insert( currentPage );
 
         // Create a normalized rectangle around the search match that includes a 5% buffer on all sides.
         const Okular::NormalizedRect matchRectWithBuffer = Okular::NormalizedRect( match->first().left - 0.05,
                                                                                    match->first().top - 0.05,
                                                                                    match->first().right + 0.05,
                                                                                    match->first().bottom + 0.05 );
 
         const bool matchRectFullyVisible = isNormalizedRectangleFullyVisible( matchRectWithBuffer, currentPage );
 
         // ..move the viewport to show the first of the searched word sequence centered
         if ( moveViewport && !matchRectFullyVisible )
         {
             DocumentViewport searchViewport( currentPage );
             searchViewport.rePos.enabled = true;
             searchViewport.rePos.normalizedX = (match->first().left + match->first().right) / 2.0;
             searchViewport.rePos.normalizedY = (match->first().top + match->first().bottom) / 2.0;
             m_parent->setViewport( searchViewport, 0, true );
         }
         delete match;
     }
 
     // notify observers about highlights changes
     foreach(int pageNumber, *pagesToNotify)
         foreach(DocumentObserver *observer, m_observers)
             observer->notifyPageChanged( pageNumber, DocumentObserver::Highlights );
 
     if (foundAMatch) emit m_parent->searchFinished( searchID, Document::MatchFound );
     else emit m_parent->searchFinished( searchID, Document::NoMatchFound );
 
     delete pagesToNotify;
 }
 
 void DocumentPrivate::doContinueAllDocumentSearch(void *pagesToNotifySet, void *pageMatchesMap, int currentPage, int searchID)
 {
     QMap< Page *, QVector<RegularAreaRect *> > *pageMatches = static_cast< QMap< Page *, QVector<RegularAreaRect *> > * >(pageMatchesMap);
     QSet< int > *pagesToNotify = static_cast< QSet< int > * >( pagesToNotifySet );
     RunningSearch *search = m_searches.value(searchID);
 
     if (m_searchCancelled || !search)
     {
         typedef QVector<RegularAreaRect *> MatchesVector;
 
         QApplication::restoreOverrideCursor();
 
         if (search) search->isCurrentlySearching = false;
 
         emit m_parent->searchFinished( searchID, Document::SearchCancelled );
         foreach(const MatchesVector &mv, *pageMatches) qDeleteAll(mv);
         delete pageMatches;
         delete pagesToNotify;
         return;
     }
 
     if (currentPage < m_pagesVector.count())
     {
         // get page (from the first to the last)
         Page *page = m_pagesVector.at(currentPage);
         int pageNumber = page->number(); // redundant? is it == currentPage ?
 
         // request search page if needed
         if ( !page->hasTextPage() )
             m_parent->requestTextPage( pageNumber );
 
         // loop on a page adding highlights for all found items
         RegularAreaRect * lastMatch = 0;
         while ( 1 )
         {
             if ( lastMatch )
                 lastMatch = page->findText( searchID, search->cachedString, NextResult, search->cachedCaseSensitivity, lastMatch );
             else
                 lastMatch = page->findText( searchID, search->cachedString, FromTop, search->cachedCaseSensitivity );
 
             if ( !lastMatch )
                 break;
 
             // add highligh rect to the matches map
             (*pageMatches)[page].append(lastMatch);
         }
         delete lastMatch;
 
         QMetaObject::invokeMethod(m_parent, "doContinueAllDocumentSearch", Qt::QueuedConnection, Q_ARG(void *, pagesToNotifySet), Q_ARG(void *, pageMatches), Q_ARG(int, currentPage + 1), Q_ARG(int, searchID));
     }
     else
     {
         // reset cursor to previous shape
         QApplication::restoreOverrideCursor();
 
         search->isCurrentlySearching = false;
         bool foundAMatch = pageMatches->count() != 0;
         QMap< Page *, QVector<RegularAreaRect *> >::const_iterator it, itEnd;
         it = pageMatches->constBegin();
         itEnd = pageMatches->constEnd();
         for ( ; it != itEnd; ++it)
         {
             foreach(RegularAreaRect *match, it.value())
             {
                 it.key()->d->setHighlight( searchID, match, search->cachedColor );
                 delete match;
             }
             search->highlightedPages.insert( it.key()->number() );
             pagesToNotify->insert( it.key()->number() );
         }
 
         foreach(DocumentObserver *observer, m_observers)
             observer->notifySetup( m_pagesVector, 0 );
 
         // notify observers about highlights changes
         foreach(int pageNumber, *pagesToNotify)
             foreach(DocumentObserver *observer, m_observers)
                 observer->notifyPageChanged( pageNumber, DocumentObserver::Highlights );
 
         if (foundAMatch) emit m_parent->searchFinished(searchID, Document::MatchFound );
         else emit m_parent->searchFinished( searchID, Document::NoMatchFound );
 
         delete pageMatches;
         delete pagesToNotify;
     }
 }
 
 void DocumentPrivate::doContinueGooglesDocumentSearch(void *pagesToNotifySet, void *pageMatchesMap, int currentPage, int searchID, const QStringList & words)
 {
     typedef QPair<RegularAreaRect *, QColor> MatchColor;
     QMap< Page *, QVector<MatchColor> > *pageMatches = static_cast< QMap< Page *, QVector<MatchColor> > * >(pageMatchesMap);
     QSet< int > *pagesToNotify = static_cast< QSet< int > * >( pagesToNotifySet );
     RunningSearch *search = m_searches.value(searchID);
 
     if (m_searchCancelled || !search)
     {
         typedef QVector<MatchColor> MatchesVector;
 
         QApplication::restoreOverrideCursor();
 
         if (search) search->isCurrentlySearching = false;
 
         emit m_parent->searchFinished( searchID, Document::SearchCancelled );
 
         foreach(const MatchesVector &mv, *pageMatches)
         {
             foreach(const MatchColor &mc, mv) delete mc.first;
         }
         delete pageMatches;
         delete pagesToNotify;
         return;
     }
 
     const int wordCount = words.count();
     const int hueStep = (wordCount > 1) ? (60 / (wordCount - 1)) : 60;
     int baseHue, baseSat, baseVal;
     search->cachedColor.getHsv( &baseHue, &baseSat, &baseVal );
 
     if (currentPage < m_pagesVector.count())
     {
         // get page (from the first to the last)
         Page *page = m_pagesVector.at(currentPage);
         int pageNumber = page->number(); // redundant? is it == currentPage ?
 
         // request search page if needed
         if ( !page->hasTextPage() )
             m_parent->requestTextPage( pageNumber );
 
         // loop on a page adding highlights for all found items
         bool allMatched = wordCount > 0,
              anyMatched = false;
         for ( int w = 0; w < wordCount; w++ )
         {
             const QString &word = words[ w ];
             int newHue = baseHue - w * hueStep;
             if ( newHue < 0 )
                 newHue += 360;
             QColor wordColor = QColor::fromHsv( newHue, baseSat, baseVal );
             RegularAreaRect * lastMatch = 0;
             // add all highlights for current word
             bool wordMatched = false;
             while ( 1 )
             {
                 if ( lastMatch )
                     lastMatch = page->findText( searchID, word, NextResult, search->cachedCaseSensitivity, lastMatch );
                 else
                     lastMatch = page->findText( searchID, word, FromTop, search->cachedCaseSensitivity);
 
                 if ( !lastMatch )
                     break;
 
                 // add highligh rect to the matches map
                 (*pageMatches)[page].append(MatchColor(lastMatch, wordColor));
                 wordMatched = true;
             }
             allMatched = allMatched && wordMatched;
             anyMatched = anyMatched || wordMatched;
         }
 
         // if not all words are present in page, remove partial highlights
         const bool matchAll = search->cachedType == Document::GoogleAll;
         if ( !allMatched && matchAll )
         {
             QVector<MatchColor> &matches = (*pageMatches)[page];
             foreach(const MatchColor &mc, matches) delete mc.first;
             pageMatches->remove(page);
         }
 
         QMetaObject::invokeMethod(m_parent, "doContinueGooglesDocumentSearch", Qt::QueuedConnection, Q_ARG(void *, pagesToNotifySet), Q_ARG(void *, pageMatches), Q_ARG(int, currentPage + 1), Q_ARG(int, searchID), Q_ARG(QStringList, words));
     }
     else
     {
         // reset cursor to previous shape
         QApplication::restoreOverrideCursor();
 
         search->isCurrentlySearching = false;
         bool foundAMatch = pageMatches->count() != 0;
         QMap< Page *, QVector<MatchColor> >::const_iterator it, itEnd;
         it = pageMatches->constBegin();
         itEnd = pageMatches->constEnd();
         for ( ; it != itEnd; ++it)
         {
             foreach(const MatchColor &mc, it.value())
             {
                 it.key()->d->setHighlight( searchID, mc.first, mc.second );
                 delete mc.first;
             }
             search->highlightedPages.insert( it.key()->number() );
             pagesToNotify->insert( it.key()->number() );
         }
 
         // send page lists to update observers (since some filter on bookmarks)
         foreach(DocumentObserver *observer, m_observers)
             observer->notifySetup( m_pagesVector, 0 );
 
         // notify observers about highlights changes
         foreach(int pageNumber, *pagesToNotify)
             foreach(DocumentObserver *observer, m_observers)
                 observer->notifyPageChanged( pageNumber, DocumentObserver::Highlights );
 
         if (foundAMatch) emit m_parent->searchFinished( searchID, Document::MatchFound );
         else emit m_parent->searchFinished( searchID, Document::NoMatchFound );
 
         delete pageMatches;
         delete pagesToNotify;
     }
 }
 
 QVariant DocumentPrivate::documentMetaData( const Generator::DocumentMetaDataKey key, const QVariant &option ) const
 {
     switch ( key )
     {
         case Generator::PaperColorMetaData:
         {
             bool giveDefault = option.toBool();
             QColor color;
             if ( ( SettingsCore::renderMode() == SettingsCore::EnumRenderMode::Paper )
                 && SettingsCore::changeColors() )
             {
                 color = SettingsCore::paperColor();
             }
             else if ( giveDefault )
             {
                 color = Qt::white;
             }
             return color;
         }
         break;
 
         case Generator::TextAntialiasMetaData:
             switch ( SettingsCore::textAntialias() )
             {
                 case SettingsCore::EnumTextAntialias::Enabled:
                     return true;
                     break;
 #if 0
                 case Settings::EnumTextAntialias::UseKDESettings:
                     // TODO: read the KDE configuration
                     return true;
                     break;
 #endif
                 case SettingsCore::EnumTextAntialias::Disabled:
                     return false;
                     break;
             }
         break;
 
         case Generator::GraphicsAntialiasMetaData:
             switch ( SettingsCore::graphicsAntialias() )
             {
                 case SettingsCore::EnumGraphicsAntialias::Enabled:
                     return true;
                     break;
                 case SettingsCore::EnumGraphicsAntialias::Disabled:
                     return false;
                     break;
             }
         break;
 
         case Generator::TextHintingMetaData:
             switch ( SettingsCore::textHinting() )
             {
                 case SettingsCore::EnumTextHinting::Enabled:
                     return true;
                     break;
                 case SettingsCore::EnumTextHinting::Disabled:
                     return false;
                     break;
             }
         break;
     }
     return QVariant();
 }
 
 bool DocumentPrivate::isNormalizedRectangleFullyVisible( const Okular::NormalizedRect & rectOfInterest, int rectPage )
 {
     bool rectFullyVisible = false;
     const QVector<Okular::VisiblePageRect *> & visibleRects = m_parent->visiblePageRects();
     QVector<Okular::VisiblePageRect *>::const_iterator vEnd = visibleRects.end();
     QVector<Okular::VisiblePageRect *>::const_iterator vIt = visibleRects.begin();
 
     for ( ; ( vIt != vEnd ) && !rectFullyVisible; ++vIt )
     {
         if ( (*vIt)->pageNumber == rectPage &&
             (*vIt)->rect.contains( rectOfInterest.left, rectOfInterest.top ) &&
             (*vIt)->rect.contains( rectOfInterest.right, rectOfInterest.bottom ) )
         {
             rectFullyVisible = true;
         }
     }
     return rectFullyVisible;
 }
 
 struct pdfsyncpoint
 {
     QString file;
     qlonglong x;
     qlonglong y;
     int row;
     int column;
     int page;
 };
 
 void DocumentPrivate::loadSyncFile( const QString & filePath )
 {
     QFile f( filePath + QLatin1String( "sync" ) );
     if ( !f.open( QIODevice::ReadOnly ) )
         return;
 
     QTextStream ts( &f );
     // first row: core name of the pdf output
     const QString coreName = ts.readLine();
     // second row: version string, in the form 'Version %u'
     QString versionstr = ts.readLine();
     QRegExp versionre( QStringLiteral("Version (\\d+)") );
     versionre.setCaseSensitivity( Qt::CaseInsensitive );
     if ( !versionre.exactMatch( versionstr ) )
         return;
 
     QHash<int, pdfsyncpoint> points;
     QStack<QString> fileStack;
     int currentpage = -1;
     const QLatin1String texStr( ".tex" );
     const QChar spaceChar = QChar::fromLatin1( ' ' );
 
     fileStack.push( coreName + texStr );
 
     const QSizeF dpi = m_generator->dpi();
 
     QString line;
     while ( !ts.atEnd() )
     {
         line = ts.readLine();
         const QStringList tokens = line.split( spaceChar, QString::SkipEmptyParts );
         const int tokenSize = tokens.count();
         if ( tokenSize < 1 )
             continue;
         if ( tokens.first() == QLatin1String( "l" ) && tokenSize >= 3 )
         {
             int id = tokens.at( 1 ).toInt();
             QHash<int, pdfsyncpoint>::const_iterator it = points.constFind( id );
             if ( it == points.constEnd() )
             {
                 pdfsyncpoint pt;
                 pt.x = 0;
                 pt.y = 0;
                 pt.row = tokens.at( 2 ).toInt();
                 pt.column = 0; // TODO
                 pt.page = -1;
                 pt.file = fileStack.top();
                 points[ id ] = pt;
             }
         }
         else if ( tokens.first() == QLatin1String( "s" ) && tokenSize >= 2 )
         {
             currentpage = tokens.at( 1 ).toInt() - 1;
         }
         else if ( tokens.first() == QLatin1String( "p*" ) && tokenSize >= 4 )
         {
             // TODO
             qCDebug(OkularCoreDebug) << "PdfSync: 'p*' line ignored";
         }
         else if ( tokens.first() == QLatin1String( "p" ) && tokenSize >= 4 )
         {
             int id = tokens.at( 1 ).toInt();
             QHash<int, pdfsyncpoint>::iterator it = points.find( id );
             if ( it != points.end() )
             {
                 it->x = tokens.at( 2 ).toInt();
                 it->y = tokens.at( 3 ).toInt();
                 it->page = currentpage;
             }
         }
         else if ( line.startsWith( QLatin1Char( '(' ) ) && tokenSize == 1 )
         {
             QString newfile = line;
             // chop the leading '('
             newfile.remove( 0, 1 );
             if ( !newfile.endsWith( texStr ) )
             {
                 newfile += texStr;
             }
             fileStack.push( newfile );
         }
         else if ( line == QLatin1String( ")" ) )
         {
             if ( !fileStack.isEmpty() )
             {
                 fileStack.pop();
             }
             else
                qCDebug(OkularCoreDebug) << "PdfSync: going one level down too much";
         }
         else
             qCDebug(OkularCoreDebug).nospace() << "PdfSync: unknown line format: '" << line << "'";
 
     }
 
     QVector< QLinkedList< Okular::SourceRefObjectRect * > > refRects( m_pagesVector.size() );
     foreach ( const pdfsyncpoint& pt, points )
     {
         // drop pdfsync points not completely valid
         if ( pt.page < 0 || pt.page >= m_pagesVector.size() )
             continue;
 
         // magic numbers for TeX's RSU's (Ridiculously Small Units) conversion to pixels
         Okular::NormalizedPoint p(
             ( pt.x * dpi.width() ) / ( 72.27 * 65536.0 * m_pagesVector[pt.page]->width() ),
             ( pt.y * dpi.height() ) / ( 72.27 * 65536.0 * m_pagesVector[pt.page]->height() )
             );
         QString file = pt.file;
         Okular::SourceReference * sourceRef = new Okular::SourceReference( file, pt.row, pt.column );
         refRects[ pt.page ].append( new Okular::SourceRefObjectRect( p, sourceRef ) );
     }
     for ( int i = 0; i < refRects.size(); ++i )
         if ( !refRects.at(i).isEmpty() )
             m_pagesVector[i]->setSourceReferences( refRects.at(i) );
 }
 
 Document::Document( QWidget *widget )
     : QObject( 0 ), d( new DocumentPrivate( this ) )
 {
     d->m_widget = widget;
     d->m_bookmarkManager = new BookmarkManager( d );
     d->m_viewportIterator = d->m_viewportHistory.insert( d->m_viewportHistory.end(), DocumentViewport() );
     d->m_undoStack = new QUndoStack(this);
 
     connect( SettingsCore::self(), SIGNAL(configChanged()), this, SLOT(_o_configChanged()) );
     connect(d->m_undoStack, &QUndoStack::canUndoChanged, this, &Document::canUndoChanged);
     connect(d->m_undoStack, &QUndoStack::canRedoChanged, this, &Document::canRedoChanged);
 
     qRegisterMetaType<Okular::FontInfo>();
 }
 
 Document::~Document()
 {
     // delete generator, pages, and related stuff
     closeDocument();
 
     QSet< View * >::const_iterator viewIt = d->m_views.constBegin(), viewEnd = d->m_views.constEnd();
     for ( ; viewIt != viewEnd; ++viewIt )
     {
         View *v = *viewIt;
         v->d_func()->document = 0;
     }
 
     // delete the bookmark manager
     delete d->m_bookmarkManager;
 
     // delete the loaded generators
     QHash< QString, GeneratorInfo >::const_iterator it = d->m_loadedGenerators.constBegin(), itEnd = d->m_loadedGenerators.constEnd();
     for ( ; it != itEnd; ++it )
         d->unloadGenerator( it.value() );
     d->m_loadedGenerators.clear();
 
     // delete the private structure
     delete d;
 }
 
 QString DocumentPrivate::docDataFileName(const QUrl &url, qint64 document_size)
 {
 
     QString fn = url.fileName();
     fn = QString::number( document_size ) + QLatin1Char('.') + fn + QStringLiteral(".xml");
     QString docdataDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation)
             + QStringLiteral("/okular/docdata");
     // make sure that the okular/docdata/ directory exists (probably this used to be handled by KStandardDirs)
     if (!QFileInfo::exists(docdataDir))
     {
         qCDebug(OkularCoreDebug) << "creating docdata folder" << docdataDir;
         QDir().mkpath(docdataDir);
     }
     QString newokularfile = docdataDir + QLatin1Char('/') + fn;
     // we don't want to accidentally migrate old files when running unit tests
     if (!QFile::exists( newokularfile ) && !QStandardPaths::isTestModeEnabled())
     {
         // see if an KDE4 file still exists
         static Kdelibs4Migration k4migration;
         QString oldfile = k4migration.locateLocal("data", QStringLiteral("okular/docdata/") + fn);
         if (oldfile.isEmpty())
         {
             oldfile =  k4migration.locateLocal("data",  QStringLiteral("kpdf/") + fn);
         }
         if ( !oldfile.isEmpty() && QFile::exists( oldfile ) )
         {
             // ### copy or move?
             if ( !QFile::copy( oldfile, newokularfile ) )
                 return QString();
         }
     }
     return newokularfile;
 }
 
 QVector<KPluginMetaData> DocumentPrivate::availableGenerators()
 {
     static QVector<KPluginMetaData> result;
     if (result.isEmpty())
     {
         result = KPluginLoader::findPlugins( QLatin1String ( "okular/generators" ) );
     }
     return result;
 }
 
 KPluginMetaData DocumentPrivate::generatorForMimeType(const QMimeType& type, QWidget* widget, const QVector<KPluginMetaData> &triedOffers)
 {
     // First try to find an exact match, and then look for more general ones (e. g. the plain text one)
     // Ideally we would rank these by "closeness", but that might be overdoing it
 
     const QVector<KPluginMetaData> available = availableGenerators();
     QVector<KPluginMetaData> offers;
     QVector<KPluginMetaData> exactMatches;
 
     QMimeDatabase mimeDatabase;
 
     for (const KPluginMetaData& md : available)
     {
         if (triedOffers.contains(md))
             continue;
 
         foreach (const QString& supported, md.mimeTypes())
         {
             QMimeType mimeType = mimeDatabase.mimeTypeForName(supported);
             if (mimeType == type && !exactMatches.contains(md)) {
                 exactMatches << md;
             }
 
             if (type.inherits(supported) && !offers.contains(md))
             {
                 offers << md;
             }
         }
     }
 
     if (!exactMatches.isEmpty()) {
         offers = exactMatches;
     }
 
     if (offers.isEmpty())
     {
         return KPluginMetaData();
     }
     int hRank=0;
     // best ranked offer search
     int offercount = offers.size();
     if (offercount > 1)
     {
         // sort the offers: the offers with an higher priority come before
         auto cmp = [](const KPluginMetaData& s1, const KPluginMetaData& s2)
         {
             const QString property = QStringLiteral("X-KDE-Priority");
             return s1.rawData()[property].toInt() > s2.rawData()[property].toInt();
         };
         std::stable_sort(offers.begin(), offers.end(), cmp);
 
         if (SettingsCore::chooseGenerators())
         {
             QStringList list;
             for (int i = 0; i < offercount; ++i)
             {
                 list << offers.at(i).pluginId();
             }
             ChooseEngineDialog choose(list, type, widget);
 
             if (choose.exec() == QDialog::Rejected)
                 return KPluginMetaData();
 
             hRank = choose.selectedGenerator();
         }
     }
     Q_ASSERT(hRank < offers.size());
     return offers.at(hRank);
 }
 
 Document::OpenResult Document::openDocument(const QString & docFile, const QUrl &url, const QMimeType &_mime, const QString & password )
 {
     QMimeDatabase db;
     QMimeType mime = _mime;
     QByteArray filedata;
     qint64 document_size = -1;
     bool isstdin = url.fileName() == QLatin1String( "-" );
     bool triedMimeFromFileContent = false;
     if ( !isstdin )
     {
         if ( !mime.isValid() )
             return OpenError;
 
         // docFile is always local so we can use QFileInfo on it
         QFileInfo fileReadTest( docFile );
         if ( fileReadTest.isFile() && !fileReadTest.isReadable() )
         {
             d->m_docFileName.clear();
             return OpenError;
         }
         // determine the related "xml document-info" filename
         d->m_url = url;
         d->m_docFileName = docFile;
         if ( url.isLocalFile() && !d->m_archiveData )
         {
             document_size = fileReadTest.size();
             d->m_xmlFileName = DocumentPrivate::docDataFileName(url, document_size);
         }
     }
     else
     {
         QFile qstdin;
         qstdin.open( stdin, QIODevice::ReadOnly );
         filedata = qstdin.readAll();
         mime = db.mimeTypeForData( filedata );
         if ( !mime.isValid() || mime.isDefault() )
             return OpenError;
         document_size = filedata.size();
         triedMimeFromFileContent = true;
     }
 
     // 0. load Generator
     // request only valid non-disabled plugins suitable for the mimetype
     KPluginMetaData offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget);
     if ( !offer.isValid() && !triedMimeFromFileContent )
     {
         QMimeType newmime = db.mimeTypeForFile(docFile, QMimeDatabase::MatchExtension);
         triedMimeFromFileContent = true;
         if ( newmime != mime )
         {
             mime = newmime;
             offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget);
         }
         if ( !offer.isValid() )
         {
             // There's still no offers, do a final mime search based on the filename
             // We need this because sometimes (e.g. when downloading from a webserver) the mimetype we
             // use is the one fed by the server, that may be wrong
             newmime = db.mimeTypeForUrl( url );
 
             if ( !newmime.isDefault() && newmime != mime )
             {
                 mime = newmime;
                 offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget);
             }
         }
     }
     if (!offer.isValid())
     {
         emit error( i18n( "Can not find a plugin which is able to handle the document being passed." ), -1 );
         qCWarning(OkularCoreDebug).nospace() << "No plugin for mimetype '" << mime.name() << "'.";
         return OpenError;
     }
 
     // 1. load Document
     OpenResult openResult = d->openDocumentInternal( offer, isstdin, docFile, filedata, password );
     if ( openResult == OpenError )
     {
         QVector<KPluginMetaData> triedOffers;
         triedOffers << offer;
         offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget, triedOffers);
 
         while ( offer.isValid() )
         {
             openResult = d->openDocumentInternal( offer, isstdin, docFile, filedata, password );
 
             if ( openResult == OpenError )
             {
                 triedOffers << offer;
                 offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget, triedOffers);
             }
             else break;
         }
 
         if (openResult == OpenError && !triedMimeFromFileContent )
         {
             QMimeType newmime = db.mimeTypeForFile(docFile, QMimeDatabase::MatchExtension);
             triedMimeFromFileContent = true;
             if ( newmime != mime )
             {
                 mime = newmime;
                 offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget, triedOffers);
                 while ( offer.isValid() )
                 {
                     openResult = d->openDocumentInternal( offer, isstdin, docFile, filedata, password );
 
                     if ( openResult == OpenError )
                     {
                         triedOffers << offer;
                         offer = DocumentPrivate::generatorForMimeType(mime, d->m_widget, triedOffers);
                     }
                     else break;
                 }
             }
         }
 
         if ( openResult == OpenSuccess )
         {
             // Clear errors, since we're trying various generators, maybe one of them errored out
             // but we finally succeeded
             // TODO one can still see the error message animating out but since this is a very rare
             //      condition we can leave this for future work
             emit error( QString(), -1 );
         }
     }
     if ( openResult != OpenSuccess )
     {
         return openResult;
     }
 
     // no need to check for the existence of a synctex file, no parser will be
     // created if none exists
     d->m_synctex_scanner = synctex_scanner_new_with_output_file( QFile::encodeName( docFile ).constData(), 0, 1);
     if ( !d->m_synctex_scanner && QFile::exists(docFile + QLatin1String( "sync" ) ) )
     {
         d->loadSyncFile(docFile);
     }
 
     d->m_generatorName = offer.pluginId();
     d->m_pageController = new PageController();
     connect( d->m_pageController, SIGNAL(rotationFinished(int,Okular::Page*)),
              this, SLOT(rotationFinished(int,Okular::Page*)) );
 
     bool containsExternalAnnotations = false;
     foreach ( Page * p, d->m_pagesVector )
     {
         p->d->m_doc = d;
         if ( !p->annotations().empty() )
             containsExternalAnnotations = true;
     }
 
     // Be quiet while restoring local annotations
     d->m_showWarningLimitedAnnotSupport = false;
     d->m_annotationsNeedSaveAs = false;
 
     // 2. load Additional Data (bookmarks, local annotations and metadata) about the document
     if ( d->m_archiveData )
     {
         d->loadDocumentInfo( d->m_archiveData->metadataFile );
         d->m_annotationsNeedSaveAs = true;
     }
     else
     {
         d->loadDocumentInfo();
         d->m_annotationsNeedSaveAs = ( d->canAddAnnotationsNatively() && containsExternalAnnotations );
     }
 
     d->m_showWarningLimitedAnnotSupport = true;
     d->m_bookmarkManager->setUrl( d->m_url );
 
     // 3. setup observers inernal lists and data
     foreachObserver( notifySetup( d->m_pagesVector, DocumentObserver::DocumentChanged ) );
 
     // 4. set initial page (restoring the page saved in xml if loaded)
     DocumentViewport loadedViewport = (*d->m_viewportIterator);
     if ( loadedViewport.isValid() )
     {
         (*d->m_viewportIterator) = DocumentViewport();
         if ( loadedViewport.pageNumber >= (int)d->m_pagesVector.size() )
             loadedViewport.pageNumber = d->m_pagesVector.size() - 1;
     }
     else
         loadedViewport.pageNumber = 0;
     setViewport( loadedViewport );
 
     // start bookmark saver timer
     if ( !d->m_saveBookmarksTimer )
     {
         d->m_saveBookmarksTimer = new QTimer( this );
         connect( d->m_saveBookmarksTimer, SIGNAL(timeout()), this, SLOT(saveDocumentInfo()) );
     }
     d->m_saveBookmarksTimer->start( 5 * 60 * 1000 );
 
     // start memory check timer
     if ( !d->m_memCheckTimer )
     {
         d->m_memCheckTimer = new QTimer( this );
         connect( d->m_memCheckTimer, SIGNAL(timeout()), this, SLOT(slotTimedMemoryCheck()) );
     }
     d->m_memCheckTimer->start( 2000 );
 
     const DocumentViewport nextViewport = d->nextDocumentViewport();
     if ( nextViewport.isValid() )
     {
         setViewport( nextViewport );
         d->m_nextDocumentViewport = DocumentViewport();
         d->m_nextDocumentDestination = QString();
     }
 
     AudioPlayer::instance()->d->m_currentDocument = isstdin ? QUrl() : d->m_url;
     d->m_docSize = document_size;
 
     const QStringList docScripts = d->m_generator->metaData( QStringLiteral("DocumentScripts"), QStringLiteral ( "JavaScript" ) ).toStringList();
     if ( !docScripts.isEmpty() )
     {
         d->m_scripter = new Scripter( d );
         Q_FOREACH ( const QString &docscript, docScripts )
         {
             d->m_scripter->execute( JavaScript, docscript );
         }
     }
 
     return OpenSuccess;
 }
 
 
 KXMLGUIClient* Document::guiClient()
 {
     if ( d->m_generator )
     {
         Okular::GuiInterface * iface = qobject_cast< Okular::GuiInterface * >( d->m_generator );
         if ( iface )
             return iface->guiClient();
     }
     return 0;
 }
 
 void Document::closeDocument()
 {
     // check if there's anything to close...
     if ( !d->m_generator )
         return;
 
     delete d->m_pageController;
     d->m_pageController = 0;
 
     delete d->m_scripter;
     d->m_scripter = 0;
 
      // remove requests left in queue
     d->m_pixmapRequestsMutex.lock();
     QLinkedList< PixmapRequest * >::const_iterator sIt = d->m_pixmapRequestsStack.constBegin();
     QLinkedList< PixmapRequest * >::const_iterator sEnd = d->m_pixmapRequestsStack.constEnd();
     for ( ; sIt != sEnd; ++sIt )
         delete *sIt;
     d->m_pixmapRequestsStack.clear();
     d->m_pixmapRequestsMutex.unlock();
 
     QEventLoop loop;
     bool startEventLoop = false;
     do
     {
         d->m_pixmapRequestsMutex.lock();
         startEventLoop = !d->m_executingPixmapRequests.isEmpty();
         d->m_pixmapRequestsMutex.unlock();
         if ( startEventLoop )
         {
             d->m_closingLoop = &loop;
             loop.exec();
             d->m_closingLoop = 0;
         }
     }
     while ( startEventLoop );
 
     if ( d->m_fontThread )
     {
         disconnect( d->m_fontThread, 0, this, 0 );
         d->m_fontThread->stopExtraction();
         d->m_fontThread->wait();
         d->m_fontThread = 0;
     }
 
     // stop any audio playback
     AudioPlayer::instance()->stopPlaybacks();
 
     // close the current document and save document info if a document is still opened
     if ( d->m_generator && d->m_pagesVector.size() > 0 )
     {
         d->saveDocumentInfo();
         d->m_generator->closeDocument();
     }
 
     if ( d->m_synctex_scanner )
     {
         synctex_scanner_free( d->m_synctex_scanner );
         d->m_synctex_scanner = 0;
     }
 
     // stop timers
     if ( d->m_memCheckTimer )
         d->m_memCheckTimer->stop();
     if ( d->m_saveBookmarksTimer )
         d->m_saveBookmarksTimer->stop();
 
     if ( d->m_generator )
     {
         // disconnect the generator from this document ...
         d->m_generator->d_func()->m_document = 0;
         // .. and this document from the generator signals
         disconnect( d->m_generator, 0, this, 0 );
 
         QHash< QString, GeneratorInfo >::const_iterator genIt = d->m_loadedGenerators.constFind( d->m_generatorName );
         Q_ASSERT( genIt != d->m_loadedGenerators.constEnd() );
     }
     d->m_generator = 0;
     d->m_generatorName = QString();
     d->m_url = QUrl();
     d->m_walletGenerator = 0;
     d->m_docFileName = QString();
     d->m_xmlFileName = QString();
     delete d->m_tempFile;
     d->m_tempFile = 0;
     delete d->m_archiveData;
     d->m_archiveData = 0;
     d->m_docSize = -1;
     d->m_exportCached = false;
     d->m_exportFormats.clear();
     d->m_exportToText = ExportFormat();
     d->m_fontsCached = false;
     d->m_fontsCache.clear();
     d->m_rotation = Rotation0;
 
     // send an empty list to observers (to free their data)
     foreachObserver( notifySetup( QVector< Page * >(), DocumentObserver::DocumentChanged ) );
 
     // delete pages and clear 'd->m_pagesVector' container
     QVector< Page * >::const_iterator pIt = d->m_pagesVector.constBegin();
     QVector< Page * >::const_iterator pEnd = d->m_pagesVector.constEnd();
     for ( ; pIt != pEnd; ++pIt )
         delete *pIt;
     d->m_pagesVector.clear();
 
     // clear 'memory allocation' descriptors
     qDeleteAll( d->m_allocatedPixmaps );
     d->m_allocatedPixmaps.clear();
 
     // clear 'running searches' descriptors
     QMap< int, RunningSearch * >::const_iterator rIt = d->m_searches.constBegin();
     QMap< int, RunningSearch * >::const_iterator rEnd = d->m_searches.constEnd();
     for ( ; rIt != rEnd; ++rIt )
         delete *rIt;
     d->m_searches.clear();
 
     // clear the visible areas and notify the observers
     QVector< VisiblePageRect * >::const_iterator vIt = d->m_pageRects.constBegin();
     QVector< VisiblePageRect * >::const_iterator vEnd = d->m_pageRects.constEnd();
     for ( ; vIt != vEnd; ++vIt )
         delete *vIt;
     d->m_pageRects.clear();
     foreachObserver( notifyVisibleRectsChanged() );
 
     // reset internal variables
 
     d->m_viewportHistory.clear();
     d->m_viewportHistory.append( DocumentViewport() );
     d->m_viewportIterator = d->m_viewportHistory.begin();
     d->m_allocatedPixmapsTotalMemory = 0;
     d->m_allocatedTextPagesFifo.clear();
     d->m_pageSize = PageSize();
     d->m_pageSizes.clear();
 
     d->m_documentInfo = DocumentInfo();
     d->m_documentInfoAskedKeys.clear();
 
     AudioPlayer::instance()->d->m_currentDocument = QUrl();
 
     d->m_undoStack->clear();
 }
 
 void Document::addObserver( DocumentObserver * pObserver )
 {
     Q_ASSERT( !d->m_observers.contains( pObserver ) );
     d->m_observers << pObserver;
 
     // if the observer is added while a document is already opened, tell it
     if ( !d->m_pagesVector.isEmpty() )
     {
         pObserver->notifySetup( d->m_pagesVector, DocumentObserver::DocumentChanged );
         pObserver->notifyViewportChanged( false /*disables smoothMove*/ );
     }
 }
 
 void Document::removeObserver( DocumentObserver * pObserver )
 {
     // remove observer from the map. it won't receive notifications anymore
     if ( d->m_observers.contains( pObserver ) )
     {
         // free observer's pixmap data
         QVector<Page*>::const_iterator it = d->m_pagesVector.constBegin(), end = d->m_pagesVector.constEnd();
         for ( ; it != end; ++it )
             (*it)->deletePixmap( pObserver );
 
         // [MEM] free observer's allocation descriptors
         QLinkedList< AllocatedPixmap * >::iterator aIt = d->m_allocatedPixmaps.begin();
         QLinkedList< AllocatedPixmap * >::iterator aEnd = d->m_allocatedPixmaps.end();
         while ( aIt != aEnd )
         {
             AllocatedPixmap * p = *aIt;
             if ( p->observer == pObserver )
             {
                 aIt = d->m_allocatedPixmaps.erase( aIt );
                 delete p;
             }
             else
                 ++aIt;
         }
 
         // delete observer entry from the map
         d->m_observers.remove( pObserver );
     }
 }
 
 void Document::reparseConfig()
 {
     // reparse generator config and if something changed clear Pages
     bool configchanged = false;
     if ( d->m_generator )
     {
         Okular::ConfigInterface * iface = qobject_cast< Okular::ConfigInterface * >( d->m_generator );
         if ( iface )
             configchanged = iface->reparseConfig();
     }
     if ( configchanged )
     {
         // invalidate pixmaps
         QVector<Page*>::const_iterator it = d->m_pagesVector.constBegin(), end = d->m_pagesVector.constEnd();
         for ( ; it != end; ++it ) {
             (*it)->deletePixmaps();
         }
 
         // [MEM] remove allocation descriptors
         qDeleteAll( d->m_allocatedPixmaps );
         d->m_allocatedPixmaps.clear();
         d->m_allocatedPixmapsTotalMemory = 0;
 
         // send reload signals to observers
         foreachObserver( notifyContentsCleared( DocumentObserver::Pixmap ) );
     }
 
     // free memory if in 'low' profile
     if ( SettingsCore::memoryLevel() == SettingsCore::EnumMemoryLevel::Low &&
          !d->m_allocatedPixmaps.isEmpty() && !d->m_pagesVector.isEmpty() )
         d->cleanupPixmapMemory();
 }
 
 
 bool Document::isOpened() const
 {
     return d->m_generator;
 }
 
 bool Document::canConfigurePrinter( ) const
 {
     if ( d->m_generator )
     {
         Okular::PrintInterface * iface = qobject_cast< Okular::PrintInterface * >( d->m_generator );
         return iface ? true : false;
     }
     else
         return 0;
 }
 
 DocumentInfo Document::documentInfo() const
 {
     QSet<DocumentInfo::Key> keys;
     for (Okular::DocumentInfo::Key ks = Okular::DocumentInfo::Title;
                                    ks < Okular::DocumentInfo::Invalid;
                                    ks = Okular::DocumentInfo::Key( ks+1 ) )
     {
         keys << ks;
     }
 
     return documentInfo( keys );
 }
 
 DocumentInfo Document::documentInfo( const QSet<DocumentInfo::Key> &keys ) const
 {
     DocumentInfo result = d->m_documentInfo;
     const QSet<DocumentInfo::Key> missingKeys = keys - d->m_documentInfoAskedKeys;
 
     if ( d->m_generator && !missingKeys.isEmpty() )
     {
         DocumentInfo info = d->m_generator->generateDocumentInfo( missingKeys );
 
         if ( missingKeys.contains( DocumentInfo::FilePath ) )
         {
             info.set( DocumentInfo::FilePath, currentDocument().toDisplayString() );
         }
 
         if ( d->m_docSize != -1 && missingKeys.contains( DocumentInfo::DocumentSize ) )
         {
             const QString sizeString = KFormat().formatByteSize( d->m_docSize );
             info.set( DocumentInfo::DocumentSize, sizeString );
         }
         if ( missingKeys.contains( DocumentInfo::PagesSize ) )
         {
             const QString pagesSize = d->pagesSizeString();
             if ( !pagesSize.isEmpty() )
             {
                 info.set( DocumentInfo::PagesSize, pagesSize );
             }
         }
 
         if ( missingKeys.contains( DocumentInfo::Pages ) && info.get( DocumentInfo::Pages ).isEmpty() ) {
             info.set( DocumentInfo::Pages, QString::number( this->pages() ) );
         }
 
         d->m_documentInfo.d->values.unite(info.d->values);
         d->m_documentInfo.d->titles.unite(info.d->titles);
         result.d->values.unite(info.d->values);
         result.d->titles.unite(info.d->titles);
     }
     d->m_documentInfoAskedKeys += keys;
 
     return result;
 }
 
 const DocumentSynopsis * Document::documentSynopsis() const
 {
     return d->m_generator ? d->m_generator->generateDocumentSynopsis() : NULL;
 }
 
 void Document::startFontReading()
 {
     if ( !d->m_generator || !d->m_generator->hasFeature( Generator::FontInfo ) || d->m_fontThread )
         return;
 
     if ( d->m_fontsCached )
     {
         // in case we have cached fonts, simulate a reading
         // this way the API is the same, and users no need to care about the
         // internal caching
         for ( int i = 0; i < d->m_fontsCache.count(); ++i )
         {
             emit gotFont( d->m_fontsCache.at( i ) );
             emit fontReadingProgress( i / pages() );
         }
         emit fontReadingEnded();
         return;
     }
 
     d->m_fontThread = new FontExtractionThread( d->m_generator, pages() );
     connect( d->m_fontThread, SIGNAL(gotFont(Okular::FontInfo)), this, SLOT(fontReadingGotFont(Okular::FontInfo)) );
     connect( d->m_fontThread.data(), SIGNAL(progress(int)), this, SLOT(slotFontReadingProgress(int)) );
 
     d->m_fontThread->startExtraction( /*d->m_generator->hasFeature( Generator::Threaded )*/true );
 }
 
 void Document::stopFontReading()
 {
     if ( !d->m_fontThread )
         return;
 
     disconnect( d->m_fontThread, 0, this, 0 );
     d->m_fontThread->stopExtraction();
     d->m_fontThread = 0;
     d->m_fontsCache.clear();
 }
 
 bool Document::canProvideFontInformation() const
 {
     return d->m_generator ? d->m_generator->hasFeature( Generator::FontInfo ) : false;
 }
 
 const QList<EmbeddedFile*> *Document::embeddedFiles() const
 {
     return d->m_generator ? d->m_generator->embeddedFiles() : NULL;
 }
 
 const Page * Document::page( int n ) const
 {
     return ( n < d->m_pagesVector.count() ) ? d->m_pagesVector.at(n) : 0;
 }
 
 const DocumentViewport & Document::viewport() const
 {
     return (*d->m_viewportIterator);
 }
 
 const QVector< VisiblePageRect * > & Document::visiblePageRects() const
 {
     return d->m_pageRects;
 }
 
 void Document::setVisiblePageRects( const QVector< VisiblePageRect * > & visiblePageRects, DocumentObserver *excludeObserver )
 {
     QVector< VisiblePageRect * >::const_iterator vIt = d->m_pageRects.constBegin();
     QVector< VisiblePageRect * >::const_iterator vEnd = d->m_pageRects.constEnd();
     for ( ; vIt != vEnd; ++vIt )
         delete *vIt;
     d->m_pageRects = visiblePageRects;
     // notify change to all other (different from id) observers
     foreach(DocumentObserver *o, d->m_observers)
         if ( o != excludeObserver )
             o->notifyVisibleRectsChanged();
 }
 
 uint Document::currentPage() const
 {
     return (*d->m_viewportIterator).pageNumber;
 }
 
 uint Document::pages() const
 {
     return d->m_pagesVector.size();
 }
 
 QUrl Document::currentDocument() const
 {
     return d->m_url;
 }
 
 bool Document::isAllowed( Permission action ) const
 {
     if ( action == Okular::AllowNotes && !d->m_annotationEditingEnabled )
         return false;
 
 #if !OKULAR_FORCE_DRM
     if ( KAuthorized::authorize( QStringLiteral("skip_drm") ) && !SettingsCore::obeyDRM() )
         return true;
 #endif
 
     return d->m_generator ? d->m_generator->isAllowed( action ) : false;
 }
 
 bool Document::supportsSearching() const
 {
     return d->m_generator ? d->m_generator->hasFeature( Generator::TextExtraction ) : false;
 }
 
 bool Document::supportsPageSizes() const
 {
     return d->m_generator ? d->m_generator->hasFeature( Generator::PageSizes ) : false;
 }
 
 bool Document::supportsTiles() const
 {
     return d->m_generator ? d->m_generator->hasFeature( Generator::TiledRendering ) : false;
 }
 
 PageSize::List Document::pageSizes() const
 {
     if ( d->m_generator )
     {
         if ( d->m_pageSizes.isEmpty() )
             d->m_pageSizes = d->m_generator->pageSizes();
         return d->m_pageSizes;
     }
     return PageSize::List();
 }
 
 bool Document::canExportToText() const
 {
     if ( !d->m_generator )
         return false;
 
     d->cacheExportFormats();
     return !d->m_exportToText.isNull();
 }
 
 bool Document::exportToText( const QString& fileName ) const
 {
     if ( !d->m_generator )
         return false;
 
     d->cacheExportFormats();
     if ( d->m_exportToText.isNull() )
         return false;
 
     return d->m_generator->exportTo( fileName, d->m_exportToText );
 }
 
 ExportFormat::List Document::exportFormats() const
 {
     if ( !d->m_generator )
         return ExportFormat::List();
 
     d->cacheExportFormats();
     return d->m_exportFormats;
 }
 
 bool Document::exportTo( const QString& fileName, const ExportFormat& format ) const
 {
     return d->m_generator ? d->m_generator->exportTo( fileName, format ) : false;
 }
 
 bool Document::historyAtBegin() const
 {
     return d->m_viewportIterator == d->m_viewportHistory.begin();
 }
 
 bool Document::historyAtEnd() const
 {
     return d->m_viewportIterator == --(d->m_viewportHistory.end());
 }
 
 QVariant Document::metaData( const QString & key, const QVariant & option ) const
 {
     // if option starts with "src:" assume that we are handling a
     // source reference
     if ( key == QLatin1String("NamedViewport")
          && option.toString().startsWith( QLatin1String("src:"), Qt::CaseInsensitive )
          && d->m_synctex_scanner)
     {
         const QString reference = option.toString();
 
         // The reference is of form "src:1111Filename", where "1111"
         // points to line number 1111 in the file "Filename".
         // Extract the file name and the numeral part from the reference string.
         // This will fail if Filename starts with a digit.
         QString name, lineString;
         // Remove "src:". Presence of substring has been checked before this
         // function is called.
         name = reference.mid( 4 );
         // split
         int nameLength = name.length();
         int i = 0;
         for( i = 0; i < nameLength; ++i )
         {
             if ( !name[i].isDigit() ) break;
         }
         lineString = name.left( i );
         name = name.mid( i );
         // Remove spaces.
         name = name.trimmed();
         lineString = lineString.trimmed();
         // Convert line to integer.
         bool ok;
         int line = lineString.toInt( &ok );
         if (!ok) line = -1;
 
         // Use column == -1 for now.
         if( synctex_display_query( d->m_synctex_scanner, QFile::encodeName(name).constData(), line, -1 ) > 0 )
         {
             synctex_node_t node;
             // For now use the first hit. Could possibly be made smarter
             // in case there are multiple hits.
             while( ( node = synctex_next_result( d->m_synctex_scanner ) ) )
             {
                 Okular::DocumentViewport viewport;
 
                 // TeX pages start at 1.
                 viewport.pageNumber = synctex_node_page( node ) - 1;
 
                 if ( viewport.pageNumber >= 0 )
                 {
                     const QSizeF dpi = d->m_generator->dpi();
 
                     // TeX small points ...
                     double px = (synctex_node_visible_h( node ) * dpi.width()) / 72.27;
                     double py = (synctex_node_visible_v( node ) * dpi.height()) / 72.27;
                     viewport.rePos.normalizedX = px / page(viewport.pageNumber)->width();
                     viewport.rePos.normalizedY = ( py + 0.5 ) / page(viewport.pageNumber)->height();
                     viewport.rePos.enabled = true;
                     viewport.rePos.pos = Okular::DocumentViewport::Center;
 
                     return viewport.toString();
                 }
             }
         }
     }
     return d->m_generator ? d->m_generator->metaData( key, option ) : QVariant();
 }
 
 Rotation Document::rotation() const
 {
     return d->m_rotation;
 }
 
 QSizeF Document::allPagesSize() const
 {
     bool allPagesSameSize = true;
     QSizeF size;
     for (int i = 0; allPagesSameSize && i < d->m_pagesVector.count(); ++i)
     {
         const Page *p = d->m_pagesVector.at(i);
         if (i == 0) size = QSizeF(p->width(), p->height());
         else
         {
             allPagesSameSize = (size == QSizeF(p->width(), p->height()));
         }
     }
     if (allPagesSameSize) return size;
     else return QSizeF();
 }
 
 QString Document::pageSizeString(int page) const
 {
     if (d->m_generator)
     {
         if (d->m_generator->pagesSizeMetric() != Generator::None)
         {
             const Page *p = d->m_pagesVector.at( page );
             return d->localizedSize(QSizeF(p->width(), p->height()));
         }
     }
     return QString();
 }
 
 void Document::requestPixmaps( const QLinkedList< PixmapRequest * > & requests )
 {
     requestPixmaps( requests, RemoveAllPrevious );
 }
 
 void Document::requestPixmaps( const QLinkedList< PixmapRequest * > & requests, PixmapRequestFlags reqOptions )
 {
     if ( requests.isEmpty() )
         return;
 
     if ( !d->m_pageController )
     {
         // delete requests..
         QLinkedList< PixmapRequest * >::const_iterator rIt = requests.constBegin(), rEnd = requests.constEnd();
         for ( ; rIt != rEnd; ++rIt )
             delete *rIt;
         // ..and return
         return;
     }
 
     // 1. [CLEAN STACK] remove previous requests of requesterID
     // FIXME This assumes all requests come from the same observer, that is true atm but not enforced anywhere
     DocumentObserver *requesterObserver = requests.first()->observer();
     QSet< int > requestedPages;
     {
         QLinkedList< PixmapRequest * >::const_iterator rIt = requests.constBegin(), rEnd = requests.constEnd();
         for ( ; rIt != rEnd; ++rIt )
             requestedPages.insert( (*rIt)->pageNumber() );
     }
     const bool removeAllPrevious = reqOptions & RemoveAllPrevious;
     d->m_pixmapRequestsMutex.lock();
     QLinkedList< PixmapRequest * >::iterator sIt = d->m_pixmapRequestsStack.begin(), sEnd = d->m_pixmapRequestsStack.end();
     while ( sIt != sEnd )
     {
         if ( (*sIt)->observer() == requesterObserver
              && ( removeAllPrevious || requestedPages.contains( (*sIt)->pageNumber() ) ) )
         {
             // delete request and remove it from stack
             delete *sIt;
             sIt = d->m_pixmapRequestsStack.erase( sIt );
         }
         else
             ++sIt;
     }
 
     // 2. [ADD TO STACK] add requests to stack
     QLinkedList< PixmapRequest * >::const_iterator rIt = requests.constBegin(), rEnd = requests.constEnd();
     for ( ; rIt != rEnd; ++rIt )
     {
         // set the 'page field' (see PixmapRequest) and check if it is valid
         PixmapRequest * request = *rIt;
         qCDebug(OkularCoreDebug).nospace() << "request observer=" << request->observer() << " " <<request->width() << "x" << request->height() << "@" << request->pageNumber();
         if ( d->m_pagesVector.value( request->pageNumber() ) == 0 )
         {
             // skip requests referencing an invalid page (must not happen)
             delete request;
             continue;
         }
 
         request->d->mPage = d->m_pagesVector.value( request->pageNumber() );
 
         if ( request->isTile() )
         {
             // Change the current request rect so that only invalid tiles are
             // requested. Also make sure the rect is tile-aligned.
             NormalizedRect tilesRect;
             const QList<Tile> tiles = request->d->tilesManager()->tilesAt( request->normalizedRect(), TilesManager::TerminalTile );
             QList<Tile>::const_iterator tIt = tiles.constBegin(), tEnd = tiles.constEnd();
             while ( tIt != tEnd )
             {
                 const Tile &tile = *tIt;
                 if ( !tile.isValid() )
                 {
                     if ( tilesRect.isNull() )
                         tilesRect = tile.rect();
                     else
                         tilesRect |= tile.rect();
                 }
 
                 tIt++;
             }
 
             request->setNormalizedRect( tilesRect );
         }
 
         if ( !request->asynchronous() )
             request->d->mPriority = 0;
 
         // add request to the 'stack' at the right place
         if ( !request->priority() )
             // add priority zero requests to the top of the stack
             d->m_pixmapRequestsStack.append( request );
         else
         {
             // insert in stack sorted by priority
             sIt = d->m_pixmapRequestsStack.begin();
             sEnd = d->m_pixmapRequestsStack.end();
             while ( sIt != sEnd && (*sIt)->priority() > request->priority() )
                 ++sIt;
             d->m_pixmapRequestsStack.insert( sIt, request );
         }
     }
     d->m_pixmapRequestsMutex.unlock();
 
     // 3. [START FIRST GENERATION] if <NO>generator is ready, start a new generation,
     // or else (if gen is running) it will be started when the new contents will
     //come from generator (in requestDone())</NO>
     // all handling of requests put into sendGeneratorPixmapRequest
     //    if ( generator->canRequestPixmap() )
         d->sendGeneratorPixmapRequest();
 }
 
 void Document::requestTextPage( uint page )
 {
     Page * kp = d->m_pagesVector[ page ];
     if ( !d->m_generator || !kp )
         return;
 
     // Memory management for TextPages
 
     d->m_generator->generateTextPage( kp );
 }
 
 void DocumentPrivate::notifyAnnotationChanges( int page )
 {
     int flags = DocumentObserver::Annotations;
 
     if ( m_annotationsNeedSaveAs )
         flags |= DocumentObserver::NeedSaveAs;
 
     foreachObserverD( notifyPageChanged( page, flags ) );
 }
 
 void Document::addPageAnnotation( int page, Annotation * annotation )
 {
     // Transform annotation's base boundary rectangle into unrotated coordinates
     Page *p = d->m_pagesVector[page];
     QTransform t = p->d->rotationMatrix();
     annotation->d_ptr->baseTransform(t.inverted());
     QUndoCommand *uc = new AddAnnotationCommand(this->d, annotation, page);
     d->m_undoStack->push(uc);
 }
 
 bool Document::canModifyPageAnnotation( const Annotation * annotation ) const
 {
     if ( !annotation || ( annotation->flags() & Annotation::DenyWrite ) )
         return false;
 
     if ( !isAllowed(Okular::AllowNotes) )
         return false;
 
     if ( ( annotation->flags() & Annotation::External ) && !d->canModifyExternalAnnotations() )
         return false;
 
     switch ( annotation->subType() )
     {
         case Annotation::AText:
         case Annotation::ALine:
         case Annotation::AGeom:
         case Annotation::AHighlight:
         case Annotation::AStamp:
         case Annotation::AInk:
             return true;
         default:
             return false;
     }
 }
 
 void Document::prepareToModifyAnnotationProperties( Annotation * annotation )
 {
     Q_ASSERT(d->m_prevPropsOfAnnotBeingModified.isNull());
     if (!d->m_prevPropsOfAnnotBeingModified.isNull())
     {
         qCCritical(OkularCoreDebug) << "Error: Document::prepareToModifyAnnotationProperties has already been called since last call to Document::modifyPageAnnotationProperties";
         return;
     }
     d->m_prevPropsOfAnnotBeingModified = annotation->getAnnotationPropertiesDomNode();
 }
 
 void Document::modifyPageAnnotationProperties( int page, Annotation * annotation )
 {
     Q_ASSERT(!d->m_prevPropsOfAnnotBeingModified.isNull());
     if (d->m_prevPropsOfAnnotBeingModified.isNull())
     {
         qCCritical(OkularCoreDebug) << "Error: Document::prepareToModifyAnnotationProperties must be called before Annotation is modified";
         return;
     }
     QDomNode prevProps = d->m_prevPropsOfAnnotBeingModified;
     QUndoCommand *uc = new Okular::ModifyAnnotationPropertiesCommand( d,
                                                                       annotation,
                                                                       page,
                                                                       prevProps,
                                                                       annotation->getAnnotationPropertiesDomNode() );
     d->m_undoStack->push( uc );
     d->m_prevPropsOfAnnotBeingModified.clear();
 }
 
 void Document::translatePageAnnotation(int page, Annotation* annotation, const NormalizedPoint & delta )
 {
     int complete = (annotation->flags() & Okular::Annotation::BeingMoved) == 0;
     QUndoCommand *uc = new Okular::TranslateAnnotationCommand( d, annotation, page, delta, complete );
     d->m_undoStack->push(uc);
 }
 
 void Document::adjustPageAnnotation( int page, Annotation *annotation, const Okular::NormalizedPoint & delta1, const Okular::NormalizedPoint & delta2 )
 {
     const bool complete = (annotation->flags() & Okular::Annotation::BeingResized) == 0;
     QUndoCommand *uc = new Okular::AdjustAnnotationCommand( d, annotation, page, delta1, delta2, complete );
     d->m_undoStack->push(uc);
 }
 
 void Document::editPageAnnotationContents( int page, Annotation* annotation,
                                            const QString & newContents,
                                            int newCursorPos,
                                            int prevCursorPos,
                                            int prevAnchorPos
                                          )
 {
     QString prevContents = annotation->contents();
     QUndoCommand *uc = new EditAnnotationContentsCommand( d, annotation, page, newContents, newCursorPos,
                                                             prevContents, prevCursorPos, prevAnchorPos );
     d->m_undoStack->push( uc );
 }
 
 bool Document::canRemovePageAnnotation( const Annotation * annotation ) const
 {
     if ( !annotation || ( annotation->flags() & Annotation::DenyDelete ) )
         return false;
 
     if ( ( annotation->flags() & Annotation::External ) && !d->canRemoveExternalAnnotations() )
         return false;
 
     switch ( annotation->subType() )
     {
         case Annotation::AText:
         case Annotation::ALine:
         case Annotation::AGeom:
         case Annotation::AHighlight:
         case Annotation::AStamp:
         case Annotation::AInk:
         case Annotation::ACaret:
             return true;
         default:
             return false;
     }
 }
 
 void Document::removePageAnnotation( int page, Annotation * annotation )
 {
     QUndoCommand *uc = new RemoveAnnotationCommand(this->d, annotation, page);
     d->m_undoStack->push(uc);
 }
 
 void Document::removePageAnnotations( int page, const QList<Annotation*> &annotations )
 {
     d->m_undoStack->beginMacro(i18nc("remove a collection of annotations from the page", "remove annotations"));
     foreach(Annotation* annotation, annotations)
     {
         QUndoCommand *uc = new RemoveAnnotationCommand(this->d, annotation, page);
         d->m_undoStack->push(uc);
     }
     d->m_undoStack->endMacro();
 }
 
 bool DocumentPrivate::canAddAnnotationsNatively() const
 {
     Okular::SaveInterface * iface = qobject_cast< Okular::SaveInterface * >( m_generator );
 
     if ( iface && iface->supportsOption(Okular::SaveInterface::SaveChanges) &&
          iface->annotationProxy() && iface->annotationProxy()->supports(AnnotationProxy::Addition) )
         return true;
 
     return false;
 }
 
 bool DocumentPrivate::canModifyExternalAnnotations() const
 {
     Okular::SaveInterface * iface = qobject_cast< Okular::SaveInterface * >( m_generator );
 
     if ( iface && iface->supportsOption(Okular::SaveInterface::SaveChanges) &&
          iface->annotationProxy() && iface->annotationProxy()->supports(AnnotationProxy::Modification) )
         return true;
 
     return false;
 }
 
 bool DocumentPrivate::canRemoveExternalAnnotations() const
 {
     Okular::SaveInterface * iface = qobject_cast< Okular::SaveInterface * >( m_generator );
 
     if ( iface && iface->supportsOption(Okular::SaveInterface::SaveChanges) &&
          iface->annotationProxy() && iface->annotationProxy()->supports(AnnotationProxy::Removal) )
         return true;
 
     return false;
 }
 
 void Document::setPageTextSelection( int page, RegularAreaRect * rect, const QColor & color )
 {
     Page * kp = d->m_pagesVector[ page ];
     if ( !d->m_generator || !kp )
         return;
 
     // add or remove the selection basing whether rect is null or not
     if ( rect )
         kp->d->setTextSelections( rect, color );
     else
         kp->d->deleteTextSelections();
 
     // notify observers about the change
     foreachObserver( notifyPageChanged( page, DocumentObserver::TextSelection ) );
 }
 
 bool Document::canUndo() const
 {
     return d->m_undoStack->canUndo();
 }
 
 bool Document::canRedo() const
 {
     return d->m_undoStack->canRedo();
 }
 
 /* REFERENCE IMPLEMENTATION: better calling setViewport from other code
 void Document::setNextPage()
 {
     // advance page and set viewport on observers
     if ( (*d->m_viewportIterator).pageNumber < (int)d->m_pagesVector.count() - 1 )
         setViewport( DocumentViewport( (*d->m_viewportIterator).pageNumber + 1 ) );
 }
 
 void Document::setPrevPage()
 {
     // go to previous page and set viewport on observers
     if ( (*d->m_viewportIterator).pageNumber > 0 )
         setViewport( DocumentViewport( (*d->m_viewportIterator).pageNumber - 1 ) );
 }
 */
 void Document::setViewportPage( int page, DocumentObserver *excludeObserver, bool smoothMove )
 {
     // clamp page in range [0 ... numPages-1]
     if ( page < 0 )
         page = 0;
     else if ( page > (int)d->m_pagesVector.count() )
         page = d->m_pagesVector.count() - 1;
 
     // make a viewport from the page and broadcast it
     setViewport( DocumentViewport( page ), excludeObserver, smoothMove );
 }
 
 void Document::setViewport( const DocumentViewport & viewport, DocumentObserver *excludeObserver, bool smoothMove )
 {
     if ( !viewport.isValid() )
     {
         qCDebug(OkularCoreDebug) << "invalid viewport:" << viewport.toString();
         return;
     }
     if ( viewport.pageNumber >= int(d->m_pagesVector.count()) )
     {
         //qCDebug(OkularCoreDebug) << "viewport out of document:" << viewport.toString();
         return;
     }
 
     // if already broadcasted, don't redo it
     DocumentViewport & oldViewport = *d->m_viewportIterator;
     // disabled by enrico on 2005-03-18 (less debug output)
     //if ( viewport == oldViewport )
     //    qCDebug(OkularCoreDebug) << "setViewport with the same viewport.";
 
     const int oldPageNumber = oldViewport.pageNumber;
 
     // set internal viewport taking care of history
     if ( oldViewport.pageNumber == viewport.pageNumber || !oldViewport.isValid() )
     {
         // if page is unchanged save the viewport at current position in queue
         oldViewport = viewport;
     }
     else
     {
         // remove elements after viewportIterator in queue
         d->m_viewportHistory.erase( ++d->m_viewportIterator, d->m_viewportHistory.end() );
 
         // keep the list to a reasonable size by removing head when needed
         if ( d->m_viewportHistory.count() >= OKULAR_HISTORY_MAXSTEPS )
             d->m_viewportHistory.pop_front();
 
         // add the item at the end of the queue
         d->m_viewportIterator = d->m_viewportHistory.insert( d->m_viewportHistory.end(), viewport );
     }
 
     const int currentViewportPage = (*d->m_viewportIterator).pageNumber;
 
     const bool currentPageChanged = (oldPageNumber != currentViewportPage);
 
     // notify change to all other (different from id) observers
     foreach(DocumentObserver *o, d->m_observers)
     {
         if ( o != excludeObserver )
             o->notifyViewportChanged( smoothMove );
 
         if ( currentPageChanged )
             o->notifyCurrentPageChanged( oldPageNumber, currentViewportPage );
     }
 }
 
 void Document::setZoom(int factor, DocumentObserver *excludeObserver)
 {
     // notify change to all other (different from id) observers
     foreach(DocumentObserver *o, d->m_observers)
         if (o != excludeObserver)
             o->notifyZoom( factor );
 }
 
 void Document::setPrevViewport()
 // restore viewport from the history
 {
     if ( d->m_viewportIterator != d->m_viewportHistory.begin() )
     {
         const int oldViewportPage = (*d->m_viewportIterator).pageNumber;
 
         // restore previous viewport and notify it to observers
         --d->m_viewportIterator;
         foreachObserver( notifyViewportChanged( true ) );
 
         const int currentViewportPage = (*d->m_viewportIterator).pageNumber;
         if (oldViewportPage != currentViewportPage)
             foreachObserver( notifyCurrentPageChanged( oldViewportPage, currentViewportPage ) );
     }
 }
 
 void Document::setNextViewport()
 // restore next viewport from the history
 {
     QLinkedList< DocumentViewport >::const_iterator nextIterator = d->m_viewportIterator;
     ++nextIterator;
     if ( nextIterator != d->m_viewportHistory.end() )
     {
         const int oldViewportPage = (*d->m_viewportIterator).pageNumber;
 
         // restore next viewport and notify it to observers
         ++d->m_viewportIterator;
         foreachObserver( notifyViewportChanged( true ) );
 
         const int currentViewportPage = (*d->m_viewportIterator).pageNumber;
         if (oldViewportPage != currentViewportPage)
             foreachObserver( notifyCurrentPageChanged( oldViewportPage, currentViewportPage ) );
     }
 }
 
 void Document::setNextDocumentViewport( const DocumentViewport & viewport )
 {
     d->m_nextDocumentViewport = viewport;
 }
 
 void Document::setNextDocumentDestination( const QString &namedDestination )
 {
     d->m_nextDocumentDestination = namedDestination;
 }
 
 void Document::searchText( int searchID, const QString & text, bool fromStart, Qt::CaseSensitivity caseSensitivity,
                                SearchType type, bool moveViewport, const QColor & color )
 {
     d->m_searchCancelled = false;
 
     // safety checks: don't perform searches on empty or unsearchable docs
     if ( !d->m_generator || !d->m_generator->hasFeature( Generator::TextExtraction ) || d->m_pagesVector.isEmpty() )
     {
         emit searchFinished( searchID, NoMatchFound );
         return;
     }
 
     // if searchID search not recorded, create new descriptor and init params
     QMap< int, RunningSearch * >::iterator searchIt = d->m_searches.find( searchID );
     if ( searchIt == d->m_searches.end() )
     {
         RunningSearch * search = new RunningSearch();
         search->continueOnPage = -1;
         searchIt = d->m_searches.insert( searchID, search );
     }
     RunningSearch * s = *searchIt;
 
     // update search structure
     bool newText = text != s->cachedString;
     s->cachedString = text;
     s->cachedType = type;
     s->cachedCaseSensitivity = caseSensitivity;
     s->cachedViewportMove = moveViewport;
     s->cachedColor = color;
     s->isCurrentlySearching = true;
 
     // global data for search
     QSet< int > *pagesToNotify = new QSet< int >;
 
     // remove highlights from pages and queue them for notifying changes
     *pagesToNotify += s->highlightedPages;
     foreach(int pageNumber, s->highlightedPages)
         d->m_pagesVector.at(pageNumber)->d->deleteHighlights( searchID );
     s->highlightedPages.clear();
 
     // set hourglass cursor
     QApplication::setOverrideCursor( Qt::WaitCursor );
 
     // 1. ALLDOC - proces all document marking pages
     if ( type == AllDocument )
     {
         QMap< Page *, QVector<RegularAreaRect *> > *pageMatches = new QMap< Page *, QVector<RegularAreaRect *> >;
 
         // search and highlight 'text' (as a solid phrase) on all pages
         QMetaObject::invokeMethod(this, "doContinueAllDocumentSearch", Qt::QueuedConnection, Q_ARG(void *, pagesToNotify), Q_ARG(void *, pageMatches), Q_ARG(int, 0), Q_ARG(int, searchID));
     }
     // 2. NEXTMATCH - find next matching item (or start from top)
     // 3. PREVMATCH - find previous matching item (or start from bottom)
     else if ( type == NextMatch || type == PreviousMatch )
     {
         // find out from where to start/resume search from
         const bool forward = type == NextMatch;
         const int viewportPage = (*d->m_viewportIterator).pageNumber;
         const int fromStartSearchPage = forward ? 0 : d->m_pagesVector.count() - 1;
         int currentPage = fromStart ? fromStartSearchPage : ((s->continueOnPage != -1) ? s->continueOnPage : viewportPage);
         Page * lastPage = fromStart ? 0 : d->m_pagesVector[ currentPage ];
         int pagesDone = 0;
 
         // continue checking last TextPage first (if it is the current page)
         RegularAreaRect * match = 0;
         if ( lastPage && lastPage->number() == s->continueOnPage )
         {
             if ( newText )
                 match = lastPage->findText( searchID, text, forward ? FromTop : FromBottom, caseSensitivity );
             else
                 match = lastPage->findText( searchID, text, forward ? NextResult : PreviousResult, caseSensitivity, &s->continueOnMatch );
             if ( !match )
             {
                 if (forward) currentPage++;
                 else currentPage--;
                 pagesDone++;
             }
         }
 
         s->pagesDone = pagesDone;
 
         DoContinueDirectionMatchSearchStruct *searchStruct = new DoContinueDirectionMatchSearchStruct();
         searchStruct->pagesToNotify = pagesToNotify;
         searchStruct->match = match;
         searchStruct->currentPage = currentPage;
         searchStruct->searchID = searchID;
 
         QMetaObject::invokeMethod(this, "doContinueDirectionMatchSearch", Qt::QueuedConnection, Q_ARG(void *, searchStruct));
     }
     // 4. GOOGLE* - process all document marking pages
     else if ( type == GoogleAll || type == GoogleAny )
     {
         QMap< Page *, QVector< QPair<RegularAreaRect *, QColor> > > *pageMatches = new QMap< Page *, QVector<QPair<RegularAreaRect *, QColor> > >;
         const QStringList words = text.split( QLatin1Char ( ' ' ), QString::SkipEmptyParts );
 
         // search and highlight every word in 'text' on all pages
         QMetaObject::invokeMethod(this, "doContinueGooglesDocumentSearch", Qt::QueuedConnection, Q_ARG(void *, pagesToNotify), Q_ARG(void *, pageMatches), Q_ARG(int, 0), Q_ARG(int, searchID), Q_ARG(QStringList, words));
     }
 }
 
 void Document::continueSearch( int searchID )
 {
     // check if searchID is present in runningSearches
     QMap< int, RunningSearch * >::const_iterator it = d->m_searches.constFind( searchID );
     if ( it == d->m_searches.constEnd() )
     {
         emit searchFinished( searchID, NoMatchFound );
         return;
     }
 
     // start search with cached parameters from last search by searchID
     RunningSearch * p = *it;
     if ( !p->isCurrentlySearching )
         searchText( searchID, p->cachedString, false, p->cachedCaseSensitivity,
                     p->cachedType, p->cachedViewportMove, p->cachedColor );
 }
 
 void Document::continueSearch( int searchID, SearchType type )
 {
     // check if searchID is present in runningSearches
     QMap< int, RunningSearch * >::const_iterator it = d->m_searches.constFind( searchID );
     if ( it == d->m_searches.constEnd() )
     {
         emit searchFinished( searchID, NoMatchFound );
         return;
     }
 
     // start search with cached parameters from last search by searchID
     RunningSearch * p = *it;
     if ( !p->isCurrentlySearching )
         searchText( searchID, p->cachedString, false, p->cachedCaseSensitivity,
                     type, p->cachedViewportMove, p->cachedColor );
 }
 
 void Document::resetSearch( int searchID )
 {
     // if we are closing down, don't bother doing anything
     if ( !d->m_generator )
         return;
 
     // check if searchID is present in runningSearches
     QMap< int, RunningSearch * >::iterator searchIt = d->m_searches.find( searchID );
     if ( searchIt == d->m_searches.end() )
         return;
 
     // get previous parameters for search
     RunningSearch * s = *searchIt;
 
     // unhighlight pages and inform observers about that
     foreach(int pageNumber, s->highlightedPages)
     {
         d->m_pagesVector.at(pageNumber)->d->deleteHighlights( searchID );
         foreachObserver( notifyPageChanged( pageNumber, DocumentObserver::Highlights ) );
     }
 
     // send the setup signal too (to update views that filter on matches)
     foreachObserver( notifySetup( d->m_pagesVector, 0 ) );
 
     // remove serch from the runningSearches list and delete it
     d->m_searches.erase( searchIt );
     delete s;
 }
 
 void Document::cancelSearch()
 {
     d->m_searchCancelled = true;
 }
 
 void Document::undo()
 {
     d->m_undoStack->undo();
 }
 
 void Document::redo()
 {
     d->m_undoStack->redo();
 }
 
 void Document::editFormText( int pageNumber,
                              Okular::FormFieldText* form,
                              const QString & newContents,
                              int newCursorPos,
                              int prevCursorPos,
                              int prevAnchorPos )
 {
     QUndoCommand *uc = new EditFormTextCommand( this->d, form, pageNumber, newContents, newCursorPos, form->text(), prevCursorPos, prevAnchorPos );
     d->m_undoStack->push( uc );
 
     d->recalculateForms();
 }
 
 void Document::editFormList( int pageNumber,
                              FormFieldChoice* form,
                              const QList< int > & newChoices )
 {
     const QList< int > prevChoices = form->currentChoices();
     QUndoCommand *uc = new EditFormListCommand( this->d, form, pageNumber, newChoices, prevChoices );
     d->m_undoStack->push( uc );
 
     d->recalculateForms();
 }
 
 void Document::editFormCombo( int pageNumber,
                               FormFieldChoice* form,
                               const QString & newText,
                               int newCursorPos,
                               int prevCursorPos,
                               int prevAnchorPos )
 {
 
     QString prevText;
     if ( form->currentChoices().isEmpty() )
     {
         prevText = form->editChoice();
     }
     else
     {
         prevText = form->choices()[form->currentChoices().constFirst()];
     }
 
     QUndoCommand *uc = new EditFormComboCommand( this->d, form, pageNumber, newText, newCursorPos, prevText, prevCursorPos, prevAnchorPos );
     d->m_undoStack->push( uc );
 
     d->recalculateForms();
 }
 
 void Document::editFormButtons( int pageNumber, const QList< FormFieldButton* >& formButtons, const QList< bool >& newButtonStates )
 {
     QUndoCommand *uc = new EditFormButtonsCommand( this->d, pageNumber, formButtons, newButtonStates );
     d->m_undoStack->push( uc );
 }
 
 void Document::reloadDocument() const
 {
     const int numOfPages = pages();
     for( int i = currentPage(); i >= 0; i -- )
         d->refreshPixmaps( i );
     for( int i = currentPage() + 1; i < numOfPages; i ++ )
         d->refreshPixmaps( i );
 }
 
 BookmarkManager * Document::bookmarkManager() const
 {
     return d->m_bookmarkManager;
 }
 
 QList<int> Document::bookmarkedPageList() const
 {
     QList<int> list;
     uint docPages = pages();
 
     //pages are 0-indexed internally, but 1-indexed externally
     for ( uint i = 0; i < docPages; i++ )
     {
         if ( bookmarkManager()->isBookmarked( i ) )
         {
             list << i + 1;
         }
     }
     return list;
 }
 
 QString Document::bookmarkedPageRange() const
 {
     // Code formerly in Part::slotPrint()
     // range detecting
     QString range;
     uint docPages = pages();
     int startId = -1;
     int endId = -1;
 
     for ( uint i = 0; i < docPages; ++i )
     {
         if ( bookmarkManager()->isBookmarked( i ) )
         {
             if ( startId < 0 )
                 startId = i;
             if ( endId < 0 )
                 endId = startId;
             else
                 ++endId;
         }
         else if ( startId >= 0 && endId >= 0 )
         {
             if ( !range.isEmpty() )
                 range += QLatin1Char ( ',' );
 
             if ( endId - startId > 0 )
                 range += QStringLiteral( "%1-%2" ).arg( startId + 1 ).arg( endId + 1 );
             else
                 range += QString::number( startId + 1 );
             startId = -1;
             endId = -1;
         }
     }
     if ( startId >= 0 && endId >= 0 )
     {
         if ( !range.isEmpty() )
             range += QLatin1Char ( ',' );
 
         if ( endId - startId > 0 )
             range += QStringLiteral( "%1-%2" ).arg( startId + 1 ).arg( endId + 1 );
         else
             range += QString::number( startId + 1 );
     }
     return range;
 }
 
 void Document::processAction( const Action * action )
 {
     if ( !action )
         return;
 
     switch( action->actionType() )
     {
         case Action::Goto: {
             const GotoAction * go = static_cast< const GotoAction * >( action );
             d->m_nextDocumentViewport = go->destViewport();
             d->m_nextDocumentDestination = go->destinationName();
 
             // Explanation of why d->m_nextDocumentViewport is needed:
             // all openRelativeFile does is launch a signal telling we
             // want to open another URL, the problem is that when the file is
             // non local, the loading is done assynchronously so you can't
             // do a setViewport after the if as it was because you are doing the setViewport
             // on the old file and when the new arrives there is no setViewport for it and
             // it does not show anything
 
             // first open filename if link is pointing outside this document
             if ( go->isExternal() && !d->openRelativeFile( go->fileName() ) )
             {
                 qCWarning(OkularCoreDebug).nospace() << "Action: Error opening '" << go->fileName() << "'.";
                 return;
             }
             else
             {
                 const DocumentViewport nextViewport = d->nextDocumentViewport();
                 // skip local links that point to nowhere (broken ones)
                 if ( !nextViewport.isValid() )
                     return;
 
                 setViewport( nextViewport, 0, true );
                 d->m_nextDocumentViewport = DocumentViewport();
                 d->m_nextDocumentDestination = QString();
             }
 
             } break;
 
         case Action::Execute: {
             const ExecuteAction * exe  = static_cast< const ExecuteAction * >( action );
             const QString fileName = exe->fileName();
             if ( fileName.endsWith( QLatin1String(".pdf"), Qt::CaseInsensitive ) )
             {
                 d->openRelativeFile( fileName );
                 return;
             }
 
             // Albert: the only pdf i have that has that kind of link don't define
             // an application and use the fileName as the file to open
             QUrl url = d->giveAbsoluteUrl( fileName );
             QMimeDatabase db;
             QMimeType mime = db.mimeTypeForUrl( url );
             // Check executables
             if ( KRun::isExecutableFile( url, mime.name() ) )
             {
                 // Don't have any pdf that uses this code path, just a guess on how it should work
                 if ( !exe->parameters().isEmpty() )
                 {
                     url = d->giveAbsoluteUrl( exe->parameters() );
                     mime = db.mimeTypeForUrl( url );
 
                     if ( KRun::isExecutableFile( url, mime.name() ) )
                     {
                         // this case is a link pointing to an executable with a parameter
                         // that also is an executable, possibly a hand-crafted pdf
                         KMessageBox::information( d->m_widget, i18n("The document is trying to execute an external application and, for your safety, Okular does not allow that.") );
                         return;
                     }
                 }
                 else
                 {
                     // this case is a link pointing to an executable with no parameters
                     // core developers find unacceptable executing it even after asking the user
                     KMessageBox::information( d->m_widget, i18n("The document is trying to execute an external application and, for your safety, Okular does not allow that.") );
                     return;
                 }
             }
 
             KService::Ptr ptr = KMimeTypeTrader::self()->preferredService( mime.name(), QStringLiteral("Application") );
             if ( ptr )
             {
                 QList<QUrl> lst;
                 lst.append( url );
                 KRun::runService( *ptr, lst, 0 );
             }
             else
                 KMessageBox::information( d->m_widget, i18n( "No application found for opening file of mimetype %1.", mime.name() ) );
             } break;
 
         case Action::DocAction: {
             const DocumentAction * docaction = static_cast< const DocumentAction * >( action );
             switch( docaction->documentActionType() )
             {
                 case DocumentAction::PageFirst:
                     setViewportPage( 0 );
                     break;
                 case DocumentAction::PagePrev:
                     if ( (*d->m_viewportIterator).pageNumber > 0 )
                         setViewportPage( (*d->m_viewportIterator).pageNumber - 1 );
                     break;
                 case DocumentAction::PageNext:
                     if ( (*d->m_viewportIterator).pageNumber < (int)d->m_pagesVector.count() - 1 )
                         setViewportPage( (*d->m_viewportIterator).pageNumber + 1 );
                     break;
                 case DocumentAction::PageLast:
                     setViewportPage( d->m_pagesVector.count() - 1 );
                     break;
                 case DocumentAction::HistoryBack:
                     setPrevViewport();
                     break;
                 case DocumentAction::HistoryForward:
                     setNextViewport();
                     break;
                 case DocumentAction::Quit:
                     emit quit();
                     break;
                 case DocumentAction::Presentation:
                     emit linkPresentation();
                     break;
                 case DocumentAction::EndPresentation:
                     emit linkEndPresentation();
                     break;
                 case DocumentAction::Find:
                     emit linkFind();
                     break;
                 case DocumentAction::GoToPage:
                     emit linkGoToPage();
                     break;
                 case DocumentAction::Close:
                     emit close();
                     break;
             }
             } break;
 
         case Action::Browse: {
             const BrowseAction * browse = static_cast< const BrowseAction * >( action );
             QString lilySource;
             int lilyRow = 0, lilyCol = 0;
             // if the url is a mailto one, invoke mailer
             if ( browse->url().scheme() == QLatin1String("mailto") )
             {
                 QDesktopServices::openUrl( browse->url() );
             }
             else if ( extractLilyPondSourceReference( browse->url(), &lilySource, &lilyRow, &lilyCol ) )
             {
                 const SourceReference ref( lilySource, lilyRow, lilyCol );
                 processSourceReference( &ref );
             }
             else
             {
                 const QUrl url = browse->url();
 
                 // fix for #100366, documents with relative links that are the form of http:foo.pdf
                 if ((url.scheme() == "http") && url.host().isEmpty() && url.fileName().endsWith("pdf"))
                 {
                     d->openRelativeFile(url.fileName());
                     return;
                 }
 
                 // handle documents with relative path
                 if ( d->m_url.isValid() )
                 {
                     const QUrl realUrl = KIO::upUrl(d->m_url).resolved(url);
                     // KRun autodeletes
                     new KRun( realUrl, d->m_widget );
                 }
             }
             } break;
 
         case Action::Sound: {
             const SoundAction * linksound = static_cast< const SoundAction * >( action );
             AudioPlayer::instance()->playSound( linksound->sound(), linksound );
             } break;
 
         case Action::Script: {
             const ScriptAction * linkscript = static_cast< const ScriptAction * >( action );
             if ( !d->m_scripter )
                 d->m_scripter = new Scripter( d );
             d->m_scripter->execute( linkscript->scriptType(), linkscript->script() );
             } break;
 
         case Action::Movie:
             emit processMovieAction( static_cast< const MovieAction * >( action ) );
             break;
         case Action::Rendition: {
             const RenditionAction * linkrendition = static_cast< const RenditionAction * >( action );
             if ( !linkrendition->script().isEmpty() )
             {
                 if ( !d->m_scripter )
                     d->m_scripter = new Scripter( d );
                 d->m_scripter->execute( linkrendition->scriptType(), linkrendition->script() );
             }
 
             emit processRenditionAction( static_cast< const RenditionAction * >( action ) );
             } break;
         case Action::BackendOpaque: {
             d->m_generator->opaqueAction( static_cast< const BackendOpaqueAction * >( action ) );
             } break;
 
     }
 }
 
 void Document::processSourceReference( const SourceReference * ref )
 {
     if ( !ref )
         return;
 
     const QUrl url = d->giveAbsoluteUrl( ref->fileName() );
     if ( !url.isLocalFile() )
     {
         qCDebug(OkularCoreDebug) << url.url() << "is not a local file.";
         return;
     }
 
     const QString absFileName = url.toLocalFile();
     if ( !QFile::exists( absFileName ) )
     {
         qCDebug(OkularCoreDebug) << "No such file:" << absFileName;
         return;
     }
 
     bool handled = false;
     emit sourceReferenceActivated(absFileName, ref->row(), ref->column(), &handled);
     if(handled) {
         return;
     }
 
     static QHash< int, QString > editors;
     // init the editors table if empty (on first run, usually)
     if ( editors.isEmpty() )
     {
         editors = buildEditorsMap();
     }
 
     QHash< int, QString >::const_iterator it = editors.constFind( SettingsCore::externalEditor() );
     QString p;
     if ( it != editors.constEnd() )
         p = *it;
     else
         p = SettingsCore::externalEditorCommand();
     // custom editor not yet configured
     if ( p.isEmpty() )
         return;
 
     // manually append the %f placeholder if not specified
     if ( p.indexOf( QLatin1String( "%f" ) ) == -1 )
         p.append( QLatin1String( " %f" ) );
 
     // replacing the placeholders
     QHash< QChar, QString > map;
     map.insert( QLatin1Char ( 'f' ), absFileName );
     map.insert( QLatin1Char ( 'c' ), QString::number( ref->column() ) );
     map.insert( QLatin1Char ( 'l' ), QString::number( ref->row() ) );
     const QString cmd = KMacroExpander::expandMacrosShellQuote( p, map );
     if ( cmd.isEmpty() )
         return;
     const QStringList args = KShell::splitArgs( cmd );
     if ( args.isEmpty() )
         return;
 
     KProcess::startDetached( args );
 }
 
 const SourceReference * Document::dynamicSourceReference( int pageNr, double absX, double absY )
 {
     if  ( !d->m_synctex_scanner )
         return 0;
 
     const QSizeF dpi = d->m_generator->dpi();
 
     if (synctex_edit_query(d->m_synctex_scanner, pageNr + 1, absX * 72. / dpi.width(), absY * 72. / dpi.height()) > 0)
     {
         synctex_node_t node;
         // TODO what should we do if there is really more than one node?
         while (( node = synctex_next_result( d->m_synctex_scanner ) ))
         {
             int line = synctex_node_line(node);
             int col = synctex_node_column(node);
             // column extraction does not seem to be implemented in synctex so far. set the SourceReference default value.
             if ( col == -1 )
             {
                 col = 0;
             }
             const char *name = synctex_scanner_get_name( d->m_synctex_scanner, synctex_node_tag( node ) );
 
             return new Okular::SourceReference( QFile::decodeName( name ), line, col );
         }
     }
     return 0;
 }
 
 Document::PrintingType Document::printingSupport() const
 {
     if ( d->m_generator )
     {
 
         if ( d->m_generator->hasFeature( Generator::PrintNative ) )
         {
             return NativePrinting;
         }
 
 #ifndef Q_OS_WIN
         if ( d->m_generator->hasFeature( Generator::PrintPostscript ) )
         {
             return PostscriptPrinting;
         }
 #endif
 
     }
 
     return NoPrinting;
 }
 
 bool Document::supportsPrintToFile() const
 {
     return d->m_generator ? d->m_generator->hasFeature( Generator::PrintToFile ) : false;
 }
 
 bool Document::print( QPrinter &printer )
 {
     return d->m_generator ? d->m_generator->print( printer ) : false;
 }
 
 QString Document::printError() const
 {
     Okular::Generator::PrintError err = Generator::UnknownPrintError;
     if ( d->m_generator )
     {
         QMetaObject::invokeMethod( d->m_generator, "printError", Qt::DirectConnection, Q_RETURN_ARG(Okular::Generator::PrintError, err) );
     }
     Q_ASSERT( err != Generator::NoPrintError );
     switch ( err )
     {
         case Generator::TemporaryFileOpenPrintError:
             return i18n( "Could not open a temporary file" );
         case Generator::FileConversionPrintError:
             return i18n( "Print conversion failed" );
         case Generator::PrintingProcessCrashPrintError:
             return i18n( "Printing process crashed" );
         case Generator::PrintingProcessStartPrintError:
             return i18n( "Printing process could not start" );
         case Generator::PrintToFilePrintError:
             return i18n( "Printing to file failed" );
         case Generator::InvalidPrinterStatePrintError:
             return i18n( "Printer was in invalid state" );
         case Generator::UnableToFindFilePrintError:
             return i18n( "Unable to find file to print" );
         case Generator::NoFileToPrintError:
             return i18n( "There was no file to print" );
         case Generator::NoBinaryToPrintError:
             return i18n( "Could not find a suitable binary for printing. Make sure CUPS lpr binary is available" );
         case Generator::InvalidPageSizePrintError:
             return i18n( "The page print size is invalid" );
         case Generator::NoPrintError:
             return QString();
         case Generator::UnknownPrintError:
             return QString();
     }
 
     return QString();
 }
 
 QWidget* Document::printConfigurationWidget() const
 {
     if ( d->m_generator )
     {
         PrintInterface * iface = qobject_cast< Okular::PrintInterface * >( d->m_generator );
         return iface ? iface->printConfigurationWidget() : 0;
     }
     else
         return 0;
 }
 
 void Document::fillConfigDialog( KConfigDialog * dialog )
 {
     if ( !dialog )
         return;
 
     // ensure that we have all the generators with settings loaded
     QVector<KPluginMetaData> offers = DocumentPrivate::configurableGenerators();
     d->loadServiceList( offers );
 
     bool pagesAdded = false;
     QHash< QString, GeneratorInfo >::iterator it = d->m_loadedGenerators.begin();
     QHash< QString, GeneratorInfo >::iterator itEnd = d->m_loadedGenerators.end();
     for ( ; it != itEnd; ++it )
     {
         Okular::ConfigInterface * iface = d->generatorConfig( it.value() );
         if ( iface )
         {
             iface->addPages( dialog );
             pagesAdded = true;
         }
     }
     if ( pagesAdded )
     {
         connect( dialog, SIGNAL(settingsChanged(QString)),
                  this, SLOT(slotGeneratorConfigChanged(QString)) );
     }
 }
 
 
 QVector<KPluginMetaData> DocumentPrivate::configurableGenerators()
 {
     const QVector<KPluginMetaData> available = availableGenerators();
     QVector<KPluginMetaData> result;
     for (const KPluginMetaData& md : available)
     {
         if (md.rawData()[QStringLiteral("X-KDE-okularHasInternalSettings")].toBool())
         {
             result << md;
         }
     }
     return result;
 }
 
 KPluginMetaData Document::generatorInfo() const
 {
     if (!d->m_generator)
         return KPluginMetaData();
 
     auto genIt = d->m_loadedGenerators.constFind(d->m_generatorName);
     Q_ASSERT(genIt != d->m_loadedGenerators.constEnd());
     return genIt.value().metadata;
 }
 
 int Document::configurableGenerators() const
 {
     return DocumentPrivate::configurableGenerators().size();
 }
 
 QStringList Document::supportedMimeTypes() const
 {
     // TODO: make it a static member of DocumentPrivate?
     QStringList result = d->m_supportedMimeTypes;
     if (result.isEmpty())
     {
         const QVector<KPluginMetaData> available = DocumentPrivate::availableGenerators();
         for (const KPluginMetaData& md : available)
         {
             result << md.mimeTypes();
         }
 
         // Remove duplicate mimetypes represented by different names
         QMimeDatabase mimeDatabase;
         QSet<QMimeType> uniqueMimetypes;
         for (const QString &mimeName : result) {
             uniqueMimetypes.insert(mimeDatabase.mimeTypeForName(mimeName));
         }
         result.clear();
         for (const QMimeType &mimeType : uniqueMimetypes) {
             result.append(mimeType.name());
         }
 
         // Sorting by mimetype name doesn't make a ton of sense,
         // but ensures that the list is ordered the same way every time
         qSort(result);
 
         d->m_supportedMimeTypes = result;
     }
     return result;
 }
 
 bool Document::canSaveChanges() const
 {
     if ( !d->m_generator )
         return false;
     Q_ASSERT( !d->m_generatorName.isEmpty() );
 
     QHash< QString, GeneratorInfo >::iterator genIt = d->m_loadedGenerators.find( d->m_generatorName );
     Q_ASSERT( genIt != d->m_loadedGenerators.end() );
     SaveInterface* saveIface = d->generatorSave( genIt.value() );
     if ( !saveIface )
         return false;
 
     return saveIface->supportsOption( SaveInterface::SaveChanges );
 }
 
 bool Document::canSaveChanges( SaveCapability cap ) const
 {
     switch ( cap )
     {
         case SaveFormsCapability:
             /* Assume that if the generator supports saving, forms can be saved.
              * We have no means to actually query the generator at the moment
              * TODO: Add some method to query the generator in SaveInterface */
             return canSaveChanges();
 
         case SaveAnnotationsCapability:
             return d->canAddAnnotationsNatively();
     }
 
     return false;
 }
 
 bool Document::saveChanges( const QString &fileName )
 {
     QString errorText;
     return saveChanges( fileName, &errorText );
 }
 
 bool Document::saveChanges( const QString &fileName, QString *errorText )
 {
     if ( !d->m_generator || fileName.isEmpty() )
         return false;
     Q_ASSERT( !d->m_generatorName.isEmpty() );
 
     QHash< QString, GeneratorInfo >::iterator genIt = d->m_loadedGenerators.find( d->m_generatorName );
     Q_ASSERT( genIt != d->m_loadedGenerators.end() );
     SaveInterface* saveIface = d->generatorSave( genIt.value() );
     if ( !saveIface || !saveIface->supportsOption( SaveInterface::SaveChanges ) )
         return false;
 
     return saveIface->save( fileName, SaveInterface::SaveChanges, errorText );
 }
 
 void Document::registerView( View *view )
 {
     if ( !view )
         return;
 
     Document *viewDoc = view->viewDocument();
     if ( viewDoc )
     {
         // check if already registered for this document
         if ( viewDoc == this )
             return;
 
         viewDoc->unregisterView( view );
     }
 
     d->m_views.insert( view );
     view->d_func()->document = d;
 }
 
 void Document::unregisterView( View *view )
 {
     if ( !view )
         return;
 
     Document *viewDoc = view->viewDocument();
     if ( !viewDoc || viewDoc != this )
         return;
 
     view->d_func()->document = 0;
     d->m_views.remove( view );
 }
 
 QByteArray Document::fontData(const FontInfo &font) const
 {
     QByteArray result;
 
     if (d->m_generator)
     {
         QMetaObject::invokeMethod(d->m_generator, "requestFontData", Qt::DirectConnection, Q_ARG(Okular::FontInfo, font), Q_ARG(QByteArray *, &result));
     }
 
     return result;
 }
 
 Document::OpenResult Document::openDocumentArchive( const QString & docFile, const QUrl & url, const QString & password )
 {
     QMimeDatabase db;
     const QMimeType mime = db.mimeTypeForFile( docFile, QMimeDatabase::MatchExtension );
     if ( !mime.inherits( QStringLiteral("application/vnd.kde.okular-archive") ) )
         return OpenError;
 
     KZip okularArchive( docFile );
     if ( !okularArchive.open( QIODevice::ReadOnly ) )
         return OpenError;
 
     const KArchiveDirectory * mainDir = okularArchive.directory();
     const KArchiveEntry * mainEntry = mainDir->entry( QStringLiteral("content.xml") );
     if ( !mainEntry || !mainEntry->isFile() )
         return OpenError;
 
     std::unique_ptr< QIODevice > mainEntryDevice( static_cast< const KZipFileEntry * >( mainEntry )->createDevice() );
     QDomDocument doc;
     if ( !doc.setContent( mainEntryDevice.get() ) )
         return OpenError;
     mainEntryDevice.reset();
 
     QDomElement root = doc.documentElement();
     if ( root.tagName() != QLatin1String("OkularArchive") )
         return OpenError;
 
     QString documentFileName;
     QString metadataFileName;
     QDomElement el = root.firstChild().toElement();
     for ( ; !el.isNull(); el = el.nextSibling().toElement() )
     {
         if ( el.tagName() == QLatin1String("Files") )
         {
             QDomElement fileEl = el.firstChild().toElement();
             for ( ; !fileEl.isNull(); fileEl = fileEl.nextSibling().toElement() )
             {
                 if ( fileEl.tagName() == QLatin1String("DocumentFileName") )
                     documentFileName = fileEl.text();
                 else if ( fileEl.tagName() == QLatin1String("MetadataFileName") )
                     metadataFileName = fileEl.text();
             }
         }
     }
     if ( documentFileName.isEmpty() )
         return OpenError;
 
     const KArchiveEntry * docEntry = mainDir->entry( documentFileName );
     if ( !docEntry || !docEntry->isFile() )
         return OpenError;
 
     std::unique_ptr< ArchiveData > archiveData( new ArchiveData() );
     const int dotPos = documentFileName.indexOf( QLatin1Char('.') );
     if ( dotPos != -1 )
         archiveData->document.setFileTemplate(QDir::tempPath() + QLatin1String("/okular_XXXXXX") + documentFileName.mid(dotPos));
     if ( !archiveData->document.open() )
         return OpenError;
 
     QString tempFileName = archiveData->document.fileName();
     {
     std::unique_ptr< QIODevice > docEntryDevice( static_cast< const KZipFileEntry * >( docEntry )->createDevice() );
     copyQIODevice( docEntryDevice.get(), &archiveData->document );
     archiveData->document.close();
     }
 
     const KArchiveEntry * metadataEntry = mainDir->entry( metadataFileName );
     if ( metadataEntry && metadataEntry->isFile() )
     {
         std::unique_ptr< QIODevice > metadataEntryDevice( static_cast< const KZipFileEntry * >( metadataEntry )->createDevice() );
         archiveData->metadataFile.setFileTemplate(QDir::tempPath() + QLatin1String("/okular_XXXXXX.xml"));
         if ( archiveData->metadataFile.open() )
         {
             copyQIODevice( metadataEntryDevice.get(), &archiveData->metadataFile );
             archiveData->metadataFile.close();
         }
     }
 
     const QMimeType docMime = db.mimeTypeForFile( tempFileName, QMimeDatabase::MatchContent );
     d->m_archiveData = archiveData.get();
     d->m_archivedFileName = documentFileName;
     const OpenResult ret = openDocument( tempFileName, url, docMime, password );
 
     if ( ret == OpenSuccess )
     {
         archiveData.release();
     }
     else
     {
         d->m_archiveData = 0;
     }
 
     return ret;
 }
 
 bool Document::saveDocumentArchive( const QString &fileName )
 {
     if ( !d->m_generator )
         return false;
 
     /* If we opened an archive, use the name of original file (eg foo.pdf)
      * instead of the archive's one (eg foo.okular) */
     QString docFileName = d->m_archiveData ? d->m_archivedFileName : d->m_url.fileName();
     if ( docFileName == QLatin1String( "-" ) )
         return false;
 
     QString docPath = d->m_docFileName;
     const QFileInfo fi( docPath );
     if ( fi.isSymLink() )
         docPath = fi.symLinkTarget();
 
     KZip okularArchive( fileName );
     if ( !okularArchive.open( QIODevice::WriteOnly ) )
         return false;
 
     const KUser user;
 #ifndef Q_OS_WIN
     const KUserGroup userGroup( user.groupId() );
 #else
     const KUserGroup userGroup( QString( "" ) );
 #endif
 
     QDomDocument contentDoc( QStringLiteral("OkularArchive") );
     QDomProcessingInstruction xmlPi = contentDoc.createProcessingInstruction(
             QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"utf-8\"" ) );
     contentDoc.appendChild( xmlPi );
     QDomElement root = contentDoc.createElement( QStringLiteral("OkularArchive") );
     contentDoc.appendChild( root );
 
     QDomElement filesNode = contentDoc.createElement( QStringLiteral("Files") );
     root.appendChild( filesNode );
 
     QDomElement fileNameNode = contentDoc.createElement( QStringLiteral("DocumentFileName") );
     filesNode.appendChild( fileNameNode );
     fileNameNode.appendChild( contentDoc.createTextNode( docFileName ) );
 
     QDomElement metadataFileNameNode = contentDoc.createElement( QStringLiteral("MetadataFileName") );
     filesNode.appendChild( metadataFileNameNode );
     metadataFileNameNode.appendChild( contentDoc.createTextNode( QStringLiteral("metadata.xml") ) );
 
     // If the generator can save annotations natively, do it
     QTemporaryFile modifiedFile;
     bool annotationsSavedNatively = false;
     if ( d->canAddAnnotationsNatively() )
     {
         if ( !modifiedFile.open() )
             return false;
 
         modifiedFile.close(); // We're only interested in the file name
 
         QString errorText;
         if ( saveChanges( modifiedFile.fileName(), &errorText ) )
         {
             docPath = modifiedFile.fileName(); // Save this instead of the original file
             annotationsSavedNatively = true;
         }
         else
         {
             qCWarning(OkularCoreDebug) << "saveChanges failed: " << errorText;
             qCDebug(OkularCoreDebug) << "Falling back to saving a copy of the original file";
         }
     }
 
     QTemporaryFile metadataFile;
     PageItems saveWhat = annotationsSavedNatively ? None : AnnotationPageItems;
     if ( !d->savePageDocumentInfo( &metadataFile, saveWhat ) )
         return false;
 
     const QByteArray contentDocXml = contentDoc.toByteArray();
     const mode_t perm = 0100644;
     okularArchive.writeFile( QStringLiteral("content.xml"), contentDocXml, perm,
                               user.loginName(), userGroup.name() );
 
 
     okularArchive.addLocalFile( docPath, docFileName );
     okularArchive.addLocalFile( metadataFile.fileName(), QStringLiteral("metadata.xml") );
 
     if ( !okularArchive.close() )
         return false;
 
     return true;
 }
 
 QPrinter::Orientation Document::orientation() const
 {
     double width, height;
     int landscape, portrait;
     const Okular::Page *currentPage;
 
     // if some pages are landscape and others are not, the most common wins, as
     // QPrinter does not accept a per-page setting
     landscape = 0;
     portrait = 0;
     for (uint i = 0; i < pages(); i++)
     {
         currentPage = page(i);
         width = currentPage->width();
         height = currentPage->height();
         if (currentPage->orientation() == Okular::Rotation90 || currentPage->orientation() == Okular::Rotation270) qSwap(width, height);
         if (width > height) landscape++;
         else portrait++;
     }
     return (landscape > portrait) ? QPrinter::Landscape : QPrinter::Portrait;
 }
 
 void Document::setAnnotationEditingEnabled( bool enable )
 {
     d->m_annotationEditingEnabled = enable;
     foreachObserver( notifySetup( d->m_pagesVector, 0 ) );
 }
 
 void Document::walletDataForFile( const QString &fileName, QString *walletName, QString *walletFolder, QString *walletKey ) const
 {
     if (d->m_generator) {
         d->m_generator->walletDataForFile( fileName, walletName, walletFolder, walletKey );
     } else if (d->m_walletGenerator) {
         d->m_walletGenerator->walletDataForFile( fileName, walletName, walletFolder, walletKey );
     }
 }
 
 QAbstractItemModel * Document::layersModel() const
 {
     return d->m_generator ? d->m_generator->layersModel() : NULL;
 }
 
 void DocumentPrivate::requestDone( PixmapRequest * req )
 {
     if ( !req )
         return;
 
     if ( !m_generator || m_closingLoop )
     {
         m_pixmapRequestsMutex.lock();
         m_executingPixmapRequests.removeAll( req );
         m_pixmapRequestsMutex.unlock();
         delete req;
         if ( m_closingLoop )
             m_closingLoop->exit();
         return;
     }
 
 #ifndef NDEBUG
     if ( !m_generator->canGeneratePixmap() )
         qCDebug(OkularCoreDebug) << "requestDone with generator not in READY state.";
 #endif
 
     // [MEM] 1.1 find and remove a previous entry for the same page and id
     QLinkedList< AllocatedPixmap * >::iterator aIt = m_allocatedPixmaps.begin();
     QLinkedList< AllocatedPixmap * >::iterator aEnd = m_allocatedPixmaps.end();
     for ( ; aIt != aEnd; ++aIt )
         if ( (*aIt)->page == req->pageNumber() && (*aIt)->observer == req->observer() )
         {
             AllocatedPixmap * p = *aIt;
             m_allocatedPixmaps.erase( aIt );
             m_allocatedPixmapsTotalMemory -= p->memory;
             delete p;
             break;
         }
 
     DocumentObserver *observer = req->observer();
     if ( m_observers.contains(observer) )
     {
         // [MEM] 1.2 append memory allocation descriptor to the FIFO
         qulonglong memoryBytes = 0;
         const TilesManager *tm = req->d->tilesManager();
         if ( tm )
             memoryBytes = tm->totalMemory();
         else
             memoryBytes = 4 * req->width() * req->height();
 
         AllocatedPixmap * memoryPage = new AllocatedPixmap( req->observer(), req->pageNumber(), memoryBytes );
         m_allocatedPixmaps.append( memoryPage );
         m_allocatedPixmapsTotalMemory += memoryBytes;
 
         // 2. notify an observer that its pixmap changed
         observer->notifyPageChanged( req->pageNumber(), DocumentObserver::Pixmap );
     }
 #ifndef NDEBUG
     else
         qCWarning(OkularCoreDebug) << "Receiving a done request for the defunct observer" << observer;
 #endif
 
     // 3. delete request
     m_pixmapRequestsMutex.lock();
     m_executingPixmapRequests.removeAll( req );
     m_pixmapRequestsMutex.unlock();
     delete req;
 
     // 4. start a new generation if some is pending
     m_pixmapRequestsMutex.lock();
     bool hasPixmaps = !m_pixmapRequestsStack.isEmpty();
     m_pixmapRequestsMutex.unlock();
     if ( hasPixmaps )
         sendGeneratorPixmapRequest();
 }
 
 void DocumentPrivate::setPageBoundingBox( int page, const NormalizedRect& boundingBox )
 {
     Page * kp = m_pagesVector[ page ];
     if ( !m_generator || !kp )
         return;
 
     if ( kp->boundingBox() == boundingBox )
         return;
     kp->setBoundingBox( boundingBox );
 
     // notify observers about the change
     foreachObserverD( notifyPageChanged( page, DocumentObserver::BoundingBox ) );
 
     // TODO: For generators that generate the bbox by pixmap scanning, if the first generated pixmap is very small, the bounding box will forever be inaccurate.
     // TODO: Crop computation should also consider annotations, actions, etc. to make sure they're not cropped away.
     // TODO: Help compute bounding box for generators that create a QPixmap without a QImage, like text and plucker.
     // TODO: Don't compute the bounding box if no one needs it (e.g., Trim Borders is off).
 
 }
 
 void DocumentPrivate::calculateMaxTextPages()
 {
     int multipliers = qMax(1, qRound(getTotalMemory() / 536870912.0)); // 512 MB
     switch (SettingsCore::memoryLevel())
     {
         case SettingsCore::EnumMemoryLevel::Low:
             m_maxAllocatedTextPages = multipliers * 2;
         break;
 
         case SettingsCore::EnumMemoryLevel::Normal:
             m_maxAllocatedTextPages = multipliers * 50;
         break;
 
         case SettingsCore::EnumMemoryLevel::Aggressive:
             m_maxAllocatedTextPages = multipliers * 250;
         break;
 
         case SettingsCore::EnumMemoryLevel::Greedy:
             m_maxAllocatedTextPages = multipliers * 1250;
         break;
     }
 }
 
 void DocumentPrivate::textGenerationDone( Page *page )
 {
     if ( !m_pageController ) return;
 
     // 1. If we reached the cache limit, delete the first text page from the fifo
     if (m_allocatedTextPagesFifo.size() == m_maxAllocatedTextPages)
     {
         int pageToKick = m_allocatedTextPagesFifo.takeFirst();
         if (pageToKick != page->number()) // this should never happen but better be safe than sorry
         {
             m_pagesVector.at(pageToKick)->setTextPage( 0 ); // deletes the textpage
         }
     }
 
     // 2. Add the page to the fifo of generated text pages
     m_allocatedTextPagesFifo.append( page->number() );
 }
 
 void Document::setRotation( int r )
 {
     d->setRotationInternal( r, true );
 }
 
 void DocumentPrivate::setRotationInternal( int r, bool notify )
 {
     Rotation rotation = (Rotation)r;
     if ( !m_generator || ( m_rotation == rotation ) )
 	return;
 
     // tell the pages to rotate
     QVector< Okular::Page * >::const_iterator pIt = m_pagesVector.constBegin();
     QVector< Okular::Page * >::const_iterator pEnd = m_pagesVector.constEnd();
     for ( ; pIt != pEnd; ++pIt )
         (*pIt)->d->rotateAt( rotation );
     if ( notify )
     {
         // notify the generator that the current rotation has changed
         m_generator->rotationChanged( rotation, m_rotation );
     }
     // set the new rotation
     m_rotation = rotation;
 
     if ( notify )
     {
         foreachObserverD( notifySetup( m_pagesVector, DocumentObserver::NewLayoutForPages ) );
         foreachObserverD( notifyContentsCleared( DocumentObserver::Pixmap | DocumentObserver::Highlights | DocumentObserver::Annotations ) );
     }
     qCDebug(OkularCoreDebug) << "Rotated:" << r;
 }
 
 void Document::setPageSize( const PageSize &size )
 {
     if ( !d->m_generator || !d->m_generator->hasFeature( Generator::PageSizes ) )
         return;
 
     if ( d->m_pageSizes.isEmpty() )
         d->m_pageSizes = d->m_generator->pageSizes();
     int sizeid = d->m_pageSizes.indexOf( size );
     if ( sizeid == -1 )
         return;
 
     // tell the pages to change size
     QVector< Okular::Page * >::const_iterator pIt = d->m_pagesVector.constBegin();
     QVector< Okular::Page * >::const_iterator pEnd = d->m_pagesVector.constEnd();
     for ( ; pIt != pEnd; ++pIt )
         (*pIt)->d->changeSize( size );
     // clear 'memory allocation' descriptors
     qDeleteAll( d->m_allocatedPixmaps );
     d->m_allocatedPixmaps.clear();
     d->m_allocatedPixmapsTotalMemory = 0;
     // notify the generator that the current page size has changed
     d->m_generator->pageSizeChanged( size, d->m_pageSize );
     // set the new page size
     d->m_pageSize = size;
 
     foreachObserver( notifySetup( d->m_pagesVector, DocumentObserver::NewLayoutForPages ) );
     foreachObserver( notifyContentsCleared( DocumentObserver::Pixmap | DocumentObserver::Highlights ) );
     qCDebug(OkularCoreDebug) << "New PageSize id:" << sizeid;
 }
 
 
 /** DocumentViewport **/
 
 DocumentViewport::DocumentViewport( int n )
     : pageNumber( n )
 {
     // default settings
     rePos.enabled = false;
     rePos.normalizedX = 0.5;
     rePos.normalizedY = 0.0;
     rePos.pos = Center;
     autoFit.enabled = false;
     autoFit.width = false;
     autoFit.height = false;
 }
 
 DocumentViewport::DocumentViewport( const QString & xmlDesc )
     : pageNumber( -1 )
 {
     // default settings (maybe overridden below)
     rePos.enabled = false;
     rePos.normalizedX = 0.5;
     rePos.normalizedY = 0.0;
     rePos.pos = Center;
     autoFit.enabled = false;
     autoFit.width = false;
     autoFit.height = false;
 
     // check for string presence
     if ( xmlDesc.isEmpty() )
         return;
 
     // decode the string
     bool ok;
     int field = 0;
     QString token = xmlDesc.section( QLatin1Char(';'), field, field );
     while ( !token.isEmpty() )
     {
         // decode the current token
         if ( field == 0 )
         {
             pageNumber = token.toInt( &ok );
             if ( !ok )
                 return;
         }
         else if ( token.startsWith( QLatin1String("C1") ) )
         {
             rePos.enabled = true;
             rePos.normalizedX = token.section( QLatin1Char(':'), 1, 1 ).toDouble();
             rePos.normalizedY = token.section( QLatin1Char(':'), 2, 2 ).toDouble();
             rePos.pos = Center;
         }
         else if ( token.startsWith( QLatin1String("C2") ) )
         {
             rePos.enabled = true;
             rePos.normalizedX = token.section( QLatin1Char(':'), 1, 1 ).toDouble();
             rePos.normalizedY = token.section( QLatin1Char(':'), 2, 2 ).toDouble();
             if (token.section( QLatin1Char(':'), 3, 3 ).toInt() == 1) rePos.pos = Center;
             else rePos.pos = TopLeft;
         }
         else if ( token.startsWith( QLatin1String("AF1") ) )
         {
             autoFit.enabled = true;
             autoFit.width = token.section( QLatin1Char(':'), 1, 1 ) == QLatin1String("T");
             autoFit.height = token.section( QLatin1Char(':'), 2, 2 ) == QLatin1String("T");
         }
         // proceed tokenizing string
         field++;
         token = xmlDesc.section( QLatin1Char(';'), field, field );
     }
 }
 
 QString DocumentViewport::toString() const
 {
     // start string with page number
     QString s = QString::number( pageNumber );
     // if has center coordinates, save them on string
     if ( rePos.enabled )
         s += QStringLiteral( ";C2:" ) + QString::number( rePos.normalizedX ) +
              QLatin1Char(':') + QString::number( rePos.normalizedY ) +
              QLatin1Char(':') + QString::number( rePos.pos );
     // if has autofit enabled, save its state on string
     if ( autoFit.enabled )
         s += QStringLiteral( ";AF1:" ) + (autoFit.width ? QLatin1Char('T') : QLatin1Char('F')) +
              QLatin1Char(':') + (autoFit.height ? QLatin1Char('T') : QLatin1Char('F'));
     return s;
 }
 
 bool DocumentViewport::isValid() const
 {
     return pageNumber >= 0;
 }
 
 bool DocumentViewport::operator==( const DocumentViewport & vp ) const
 {
     bool equal = ( pageNumber == vp.pageNumber ) &&
                  ( rePos.enabled == vp.rePos.enabled ) &&
                  ( autoFit.enabled == vp.autoFit.enabled );
     if ( !equal )
         return false;
     if ( rePos.enabled &&
          (( rePos.normalizedX != vp.rePos.normalizedX) ||
          ( rePos.normalizedY != vp.rePos.normalizedY ) || rePos.pos != vp.rePos.pos) )
         return false;
     if ( autoFit.enabled &&
          (( autoFit.width != vp.autoFit.width ) ||
          ( autoFit.height != vp.autoFit.height )) )
         return false;
     return true;
 }
 
 bool DocumentViewport::operator<( const DocumentViewport & vp ) const
 {
     // TODO: Check autoFit and Position
 
     if ( pageNumber != vp.pageNumber )
         return pageNumber < vp.pageNumber;
 
     if ( !rePos.enabled && vp.rePos.enabled )
         return true;
 
     if ( !vp.rePos.enabled )
         return false;
 
     if ( rePos.normalizedY != vp.rePos.normalizedY )
         return rePos.normalizedY < vp.rePos.normalizedY;
 
     return rePos.normalizedX < vp.rePos.normalizedX;
 }
 
 
 /** DocumentInfo **/
 
 DocumentInfo::DocumentInfo() : d(new DocumentInfoPrivate())
 {
 }
 
 DocumentInfo::DocumentInfo(const DocumentInfo &info) : d(new DocumentInfoPrivate())
 {
     *this = info;
 }
 
 DocumentInfo& DocumentInfo::operator=(const DocumentInfo &info)
 {
     d->values = info.d->values;
     d->titles = info.d->titles;
     return *this;
 }
 
 DocumentInfo::~DocumentInfo()
 {
     delete d;
 }
 
 void DocumentInfo::set( const QString &key, const QString &value, const QString &title )
 {
     d->values[ key ] = value;
     d->titles[ key ] = title;
 }
 
 void DocumentInfo::set( Key key, const QString &value )
 {
     d->values[ getKeyString( key ) ] = value;
 }
 
 QStringList DocumentInfo::keys() const
 {
     return d->values.keys();
 }
 
 QString DocumentInfo::get( Key key ) const
 {
     return get( getKeyString( key ) );
 }
 
 QString DocumentInfo::get( const QString &key ) const
 {
     return d->values[ key ];
 }
 
 QString DocumentInfo::getKeyString( Key key ) //const
 {
     switch ( key ) {
         case Title:
             return QStringLiteral("title");
             break;
         case Subject:
             return QStringLiteral("subject");
             break;
         case Description:
             return QStringLiteral("description");
             break;
         case Author:
             return QStringLiteral("author");
             break;
         case Creator:
             return QStringLiteral("creator");
             break;
         case Producer:
             return QStringLiteral("producer");
             break;
         case Copyright:
             return QStringLiteral("copyright");
             break;
         case Pages:
             return QStringLiteral("pages");
             break;
         case CreationDate:
             return QStringLiteral("creationDate");
             break;
         case ModificationDate:
             return QStringLiteral("modificationDate");
             break;
         case MimeType:
             return QStringLiteral("mimeType");
             break;
         case Category:
             return QStringLiteral("category");
             break;
         case Keywords:
             return QStringLiteral("keywords");
             break;
         case FilePath:
             return QStringLiteral("filePath");
             break;
         case DocumentSize:
             return QStringLiteral("documentSize");
             break;
         case PagesSize:
             return QStringLiteral("pageSize");
             break;
         default:
             qCWarning(OkularCoreDebug) << "Unknown" << key;
             return QString();
             break;
     }
 }
 
 DocumentInfo::Key DocumentInfo::getKeyFromString( const QString &key ) //const
 {
     if (key == QLatin1String("title")) return Title;
     else if (key == QLatin1String("subject")) return Subject;
     else if (key == QLatin1String("description")) return Description;
     else if (key == QLatin1String("author")) return Author;
     else if (key == QLatin1String("creator")) return Creator;
     else if (key == QLatin1String("producer")) return Producer;
     else if (key == QLatin1String("copyright")) return Copyright;
     else if (key == QLatin1String("pages")) return Pages;
     else if (key == QLatin1String("creationDate")) return CreationDate;
     else if (key == QLatin1String("modificationDate")) return ModificationDate;
     else if (key == QLatin1String("mimeType")) return MimeType;
     else if (key == QLatin1String("category")) return Category;
     else if (key == QLatin1String("keywords")) return Keywords;
     else if (key == QLatin1String("filePath")) return FilePath;
     else if (key == QLatin1String("documentSize")) return DocumentSize;
     else if (key == QLatin1String("pageSize")) return PagesSize;
     else return Invalid;
 }
 
 QString DocumentInfo::getKeyTitle( Key key ) //const
 {
     switch ( key ) {
         case Title:
             return i18n( "Title" );
             break;
         case Subject:
             return i18n( "Subject" );
             break;
         case Description:
             return i18n( "Description" );
             break;
         case Author:
             return i18n( "Author" );
             break;
         case Creator:
             return i18n( "Creator" );
             break;
         case Producer:
             return i18n( "Producer" );
             break;
         case Copyright:
             return i18n( "Copyright" );
             break;
         case Pages:
             return i18n( "Pages" );
             break;
         case CreationDate:
             return i18n( "Created" );
             break;
         case ModificationDate:
             return i18n( "Modified" );
             break;
         case MimeType:
             return i18n( "Mime Type" );
             break;
         case Category:
             return i18n( "Category" );
             break;
         case Keywords:
             return i18n( "Keywords" );
             break;
         case FilePath:
             return i18n( "File Path" );
             break;
         case DocumentSize:
             return i18n( "File Size" );
             break;
         case PagesSize:
             return i18n("Page Size");
             break;
         default:
             return QString();
             break;
     }
 }
 
 QString DocumentInfo::getKeyTitle( const QString &key ) const
 {
     QString title = getKeyTitle ( getKeyFromString( key ) );
     if ( title.isEmpty() )
         title = d->titles[ key ];
     return title;
 }
 
 
 
 /** DocumentSynopsis **/
 
 DocumentSynopsis::DocumentSynopsis()
   : QDomDocument( QStringLiteral("DocumentSynopsis") )
 {
     // void implementation, only subclassed for naming
 }
 
 DocumentSynopsis::DocumentSynopsis( const QDomDocument &document )
   : QDomDocument( document )
 {
 }
 
 /** EmbeddedFile **/
 
 EmbeddedFile::EmbeddedFile()
 {
 }
 
 EmbeddedFile::~EmbeddedFile()
 {
 }
 
 VisiblePageRect::VisiblePageRect( int page, const NormalizedRect &rectangle )
     : pageNumber( page ), rect( rectangle )
 {
 }
 
 #undef foreachObserver
 #undef foreachObserverD
 
 #include "moc_document.cpp"
 
 /* kate: replace-tabs on; indent-width 4; */
diff --git a/core/generator.cpp b/core/generator.cpp
index 6c0750c68..7d70049cd 100644
--- a/core/generator.cpp
+++ b/core/generator.cpp
@@ -1,712 +1,700 @@
 /***************************************************************************
  *   Copyright (C) 2005   by Piotr Szymanski <niedakh@gmail.com>           *
  *   Copyright (C) 2008   by Albert Astals Cid <aacid@kde.org>             *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "generator.h"
 #include "generator_p.h"
 #include "observer.h"
 
+#include <QApplication>
 #include <qeventloop.h>
 #include <QtPrintSupport/QPrinter>
-#include <QApplication>
 
 #include <QtCore/QDebug>
 #include <QIcon>
 #include <QMimeDatabase>
 #include <KLocalizedString>
 #include <kwallet.h>
 
 #include "document.h"
 #include "document_p.h"
 #include "page.h"
 #include "page_p.h"
 #include "textpage.h"
 #include "utils.h"
 
 using namespace Okular;
 
 GeneratorPrivate::GeneratorPrivate()
     : m_document( 0 ),
       mPixmapGenerationThread( 0 ), mTextPageGenerationThread( 0 ),
       m_mutex( 0 ), m_threadsMutex( 0 ), mPixmapReady( true ), mTextPageReady( true ),
       m_closing( false ), m_closingLoop( 0 ),
       m_dpi(72.0, 72.0)
 {
 }
 
 GeneratorPrivate::~GeneratorPrivate()
 {
     if ( mPixmapGenerationThread )
         mPixmapGenerationThread->wait();
 
     delete mPixmapGenerationThread;
 
     if ( mTextPageGenerationThread )
         mTextPageGenerationThread->wait();
 
     delete mTextPageGenerationThread;
 
     delete m_mutex;
     delete m_threadsMutex;
 }
 
 PixmapGenerationThread* GeneratorPrivate::pixmapGenerationThread()
 {
     if ( mPixmapGenerationThread )
         return mPixmapGenerationThread;
 
     Q_Q( Generator );
     mPixmapGenerationThread = new PixmapGenerationThread( q );
     QObject::connect( mPixmapGenerationThread, SIGNAL(finished()), q, SLOT(pixmapGenerationFinished()),
                       Qt::QueuedConnection );
 
     return mPixmapGenerationThread;
 }
 
 TextPageGenerationThread* GeneratorPrivate::textPageGenerationThread()
 {
     if ( mTextPageGenerationThread )
         return mTextPageGenerationThread;
 
     Q_Q( Generator );
     mTextPageGenerationThread = new TextPageGenerationThread( q );
     QObject::connect( mTextPageGenerationThread, SIGNAL(finished()), q, SLOT(textpageGenerationFinished()),
                       Qt::QueuedConnection );
 
     return mTextPageGenerationThread;
 }
 
 void GeneratorPrivate::pixmapGenerationFinished()
 {
     Q_Q( Generator );
     PixmapRequest *request = mPixmapGenerationThread->request();
     mPixmapGenerationThread->endGeneration();
 
     QMutexLocker locker( threadsLock() );
     mPixmapReady = true;
 
     if ( m_closing )
     {
         delete request;
         if ( mTextPageReady )
         {
             locker.unlock();
             m_closingLoop->quit();
         }
         return;
     }
 
     const QImage& img = mPixmapGenerationThread->image();
-    QPixmap *p = new QPixmap( QPixmap::fromImage( img ) );
-    //p->setDevicePixelRatio( p->devicePixelRatioF() );
-    request->page()->setPixmap( request->observer(), p, request->normalizedRect() );
+    request->page()->setPixmap( request->observer(), new QPixmap( QPixmap::fromImage( img ) ), request->normalizedRect() );
     const int pageNumber = request->page()->number();
 
     if ( mPixmapGenerationThread->calcBoundingBox() )
         q->updatePageBoundingBox( pageNumber, mPixmapGenerationThread->boundingBox() );
     q->signalPixmapRequestDone( request );
 }
 
 void GeneratorPrivate::textpageGenerationFinished()
 {
     Q_Q( Generator );
     Page *page = mTextPageGenerationThread->page();
     mTextPageGenerationThread->endGeneration();
 
     QMutexLocker locker( threadsLock() );
     mTextPageReady = true;
 
     if ( m_closing )
     {
         delete mTextPageGenerationThread->textPage();
         if ( mPixmapReady )
         {
             locker.unlock();
             m_closingLoop->quit();
         }
         return;
     }
 
     if ( mTextPageGenerationThread->textPage() )
     {
         TextPage *tp = mTextPageGenerationThread->textPage();
         page->setTextPage( tp );
         q->signalTextGenerationDone( page, tp );
     }
 }
 
 QMutex* GeneratorPrivate::threadsLock()
 {
     if ( !m_threadsMutex )
         m_threadsMutex = new QMutex();
     return m_threadsMutex;
 }
 
 QVariant GeneratorPrivate::metaData( const QString &, const QVariant & ) const
 {
     return QVariant();
 }
 
 QImage GeneratorPrivate::image( PixmapRequest * )
 {
     return QImage();
 }
 
 
 Generator::Generator(QObject* parent, const QVariantList&)
     : QObject(parent)
     , d_ptr( new GeneratorPrivate() )
 {
     d_ptr->q_ptr = this;
 }
 
 Generator::Generator(GeneratorPrivate &dd, QObject *parent, const QVariantList &args)
     : QObject(parent), d_ptr(&dd)
 {
     d_ptr->q_ptr = this;
     Q_UNUSED(args)
 }
 
 Generator::~Generator()
 {
     delete d_ptr;
 }
 
 bool Generator::loadDocument( const QString & fileName, QVector< Page * > & pagesVector )
 {
     Q_UNUSED(fileName);
     Q_UNUSED(pagesVector);
 
     return false;
 }
 
 bool Generator::loadDocumentFromData( const QByteArray &, QVector< Page * > & )
 {
     return false;
 }
 
 Document::OpenResult Generator::loadDocumentWithPassword( const QString & fileName, QVector< Page * > & pagesVector, const QString & )
 {
     return loadDocument( fileName, pagesVector ) ? Document::OpenSuccess : Document::OpenError;
 }
 
 Document::OpenResult Generator::loadDocumentFromDataWithPassword( const QByteArray & fileData, QVector< Page * > & pagesVector, const QString & )
 {
     return loadDocumentFromData( fileData, pagesVector ) ? Document::OpenSuccess : Document::OpenError;
 }
 
 bool Generator::closeDocument()
 {
     Q_D( Generator );
 
     d->m_closing = true;
 
     d->threadsLock()->lock();
     if ( !( d->mPixmapReady && d->mTextPageReady ) )
     {
         QEventLoop loop;
         d->m_closingLoop = &loop;
 
         d->threadsLock()->unlock();
 
         loop.exec();
 
         d->m_closingLoop = 0;
     }
     else
     {
         d->threadsLock()->unlock();
     }
 
     bool ret = doCloseDocument();
 
     d->m_closing = false;
 
     return ret;
 }
 
 bool Generator::canGeneratePixmap() const
 {
     Q_D( const Generator );
     return d->mPixmapReady;
 }
 
 void Generator::generatePixmap( PixmapRequest *request )
 {
     Q_D( Generator );
     d->mPixmapReady = false;
 
     const bool calcBoundingBox = !request->isTile() && !request->page()->isBoundingBoxKnown();
 
     if ( request->asynchronous() && hasFeature( Threaded ) )
     {
         d->pixmapGenerationThread()->startGeneration( request, calcBoundingBox );
 
         /**
          * We create the text page for every page that is visible to the
          * user, so he can use the text extraction tools without a delay.
          */
         if ( hasFeature( TextExtraction ) && !request->page()->hasTextPage() && canGenerateTextPage() && !d->m_closing ) {
             d->mTextPageReady = false;
             d->textPageGenerationThread()->startGeneration( request->page() );
         }
 
         return;
     }
 
     const QImage& img = image( request );
-    QPixmap *p = new QPixmap( QPixmap::fromImage( img ) );
-    //p->setDevicePixelRatio( img.devicePixelRatioF() );
-    request->page()->setPixmap( request->observer(), p , request->normalizedRect() );
+    request->page()->setPixmap( request->observer(), new QPixmap( QPixmap::fromImage( img ) ), request->normalizedRect() );
     const int pageNumber = request->page()->number();
 
     d->mPixmapReady = true;
 
     signalPixmapRequestDone( request );
     if ( calcBoundingBox )
         updatePageBoundingBox( pageNumber, Utils::imageBoundingBox( &img ) );
 }
 
 bool Generator::canGenerateTextPage() const
 {
     Q_D( const Generator );
     return d->mTextPageReady;
 }
 
 void Generator::generateTextPage( Page *page )
 {
     TextPage *tp = textPage( page );
     page->setTextPage( tp );
     signalTextGenerationDone( page, tp );
 }
 
 QImage Generator::image( PixmapRequest *request )
 {
     Q_D( Generator );
-    QImage image = d->image( request );
-    //image.setDevicePixelRatio( request->devicePixelRatio() );
-    return image;
+    return d->image( request );
 }
 
 TextPage* Generator::textPage( Page* )
 {
     return 0;
 }
 
 DocumentInfo Generator::generateDocumentInfo(const QSet<DocumentInfo::Key> &keys) const
 {
     Q_UNUSED(keys);
 
     return DocumentInfo();
 }
 
 const DocumentSynopsis * Generator::generateDocumentSynopsis()
 {
     return 0;
 }
 
 FontInfo::List Generator::fontsForPage( int )
 {
     return FontInfo::List();
 }
 
 const QList<EmbeddedFile*> * Generator::embeddedFiles() const
 {
     return 0;
 }
 
 Generator::PageSizeMetric Generator::pagesSizeMetric() const
 {
     return None;
 }
 
 bool Generator::isAllowed( Permission ) const
 {
     return true;
 }
 
 void Generator::rotationChanged( Rotation, Rotation )
 {
 }
 
 PageSize::List Generator::pageSizes() const
 {
     return PageSize::List();
 }
 
 void Generator::pageSizeChanged( const PageSize &, const PageSize & )
 {
 }
 
 bool Generator::print( QPrinter& )
 {
     return false;
 }
 
 Generator::PrintError Generator::printError() const
 {
     return UnknownPrintError;
 }
 
 void Generator::opaqueAction( const BackendOpaqueAction * /*action*/ )
 {
 }
 
 QVariant Generator::metaData( const QString &key, const QVariant &option ) const
 {
     Q_D( const Generator );
     return d->metaData( key, option );
 }
 
 ExportFormat::List Generator::exportFormats() const
 {
     return ExportFormat::List();
 }
 
 bool Generator::exportTo( const QString&, const ExportFormat& )
 {
     return false;
 }
 
 void Generator::walletDataForFile( const QString &fileName, QString *walletName, QString *walletFolder, QString *walletKey ) const
 {
     *walletKey = fileName.section( QLatin1Char('/'), -1, -1);
     *walletName = KWallet::Wallet::NetworkWallet();
     *walletFolder = QStringLiteral("KPdf");
 }
 
 bool Generator::hasFeature( GeneratorFeature feature ) const
 {
     Q_D( const Generator );
     return d->m_features.contains( feature );
 }
 
 void Generator::signalPixmapRequestDone( PixmapRequest * request )
 {
     Q_D( Generator );
     if ( d->m_document )
         d->m_document->requestDone( request );
     else
     {
         delete request;
     }
 }
 
 void Generator::signalTextGenerationDone( Page *page, TextPage *textPage )
 {
     Q_D( Generator );
     if ( d->m_document )
         d->m_document->textGenerationDone( page );
     else
         delete textPage;
 }
 
 const Document * Generator::document() const
 {
     Q_D( const Generator );
     if ( d->m_document )
     {
         return d->m_document->m_parent;
     }
     return 0;
 }
 
 void Generator::setFeature( GeneratorFeature feature, bool on )
 {
     Q_D( Generator );
     if ( on )
         d->m_features.insert( feature );
     else
         d->m_features.remove( feature );
 }
 
 QVariant Generator::documentMetaData( const QString &key, const QVariant &option ) const
 {
     Q_D( const Generator );
     if ( !d->m_document )
         return QVariant();
 
     if (key == QLatin1String("PaperColor"))
         return documentMetaData(PaperColorMetaData, option);
     if (key == QLatin1String("GraphicsAntialias"))
         return documentMetaData(GraphicsAntialiasMetaData, option);
     if (key == QLatin1String("TextAntialias"))
         return documentMetaData(TextAntialiasMetaData, option);
     if (key == QLatin1String("TextHinting"))
         return documentMetaData(TextHintingMetaData, option);
 
     return QVariant();
 }
 
 QVariant Generator::documentMetaData( const DocumentMetaDataKey key, const QVariant &option ) const
 {
     Q_D( const Generator );
     if ( !d->m_document )
         return QVariant();
 
     return d->m_document->documentMetaData( key, option );
 }
 
 QMutex* Generator::userMutex() const
 {
     Q_D( const Generator );
     if ( !d->m_mutex )
     {
         d->m_mutex = new QMutex();
     }
     return d->m_mutex;
 }
 
 void Generator::updatePageBoundingBox( int page, const NormalizedRect & boundingBox )
 {
     Q_D( Generator );
     if ( d->m_document ) // still connected to document?
         d->m_document->setPageBoundingBox( page, boundingBox );
 }
 
 void Generator::requestFontData(const Okular::FontInfo & /*font*/, QByteArray * /*data*/)
 {
 
 }
 
 void Generator::setDPI(const QSizeF & dpi)
 {
      Q_D( Generator );
      d->m_dpi = dpi;
 }
 
 QSizeF Generator::dpi() const
 {
      Q_D( const Generator );
      return d->m_dpi;
 }
 
 QAbstractItemModel * Generator::layersModel() const
 {
     return 0;
 }
 
-PixmapRequest::PixmapRequest( DocumentObserver *observer, int pageNumber, int width, int height, qreal dpr, int priority, PixmapRequestFeatures features )
+PixmapRequest::PixmapRequest( DocumentObserver *observer, int pageNumber, int width, int height, int priority, PixmapRequestFeatures features )
   : d( new PixmapRequestPrivate )
 {
     d->mObserver = observer;
     d->mPageNumber = pageNumber;
     d->mWidth = width * qApp->devicePixelRatio();
     d->mHeight = height * qApp->devicePixelRatio();
-    d->mDpr = dpr;
     d->mPriority = priority;
     d->mFeatures = features;
     d->mForce = false;
     d->mTile = false;
     d->mNormalizedRect = NormalizedRect();
 }
 
 PixmapRequest::~PixmapRequest()
 {
     delete d;
 }
 
 DocumentObserver *PixmapRequest::observer() const
 {
     return d->mObserver;
 }
 
 int PixmapRequest::pageNumber() const
 {
     return d->mPageNumber;
 }
 
 int PixmapRequest::width() const
 {
     return d->mWidth;
 }
 
 int PixmapRequest::height() const
 {
     return d->mHeight;
 }
 
-qreal PixmapRequest::devicePixelRatio() const
-{
-    return d->mDpr;
-}
-
 int PixmapRequest::priority() const
 {
     return d->mPriority;
 }
 
 bool PixmapRequest::asynchronous() const
 {
     return d->mFeatures & Asynchronous;
 }
 
 bool PixmapRequest::preload() const
 {
     return d->mFeatures & Preload;
 }
 
 Page* PixmapRequest::page() const
 {
     return d->mPage;
 }
 
 void PixmapRequest::setTile( bool tile )
 {
     d->mTile = tile;
 }
 
 bool PixmapRequest::isTile() const
 {
     return d->mTile;
 }
 
 void PixmapRequest::setNormalizedRect( const NormalizedRect &rect )
 {
     if ( d->mNormalizedRect == rect )
         return;
 
     d->mNormalizedRect = rect;
 }
 
 const NormalizedRect& PixmapRequest::normalizedRect() const
 {
     return d->mNormalizedRect;
 }
 
 Okular::TilesManager* PixmapRequestPrivate::tilesManager() const
 {
     return mPage->d->tilesManager(mObserver);
 }
 
 void PixmapRequestPrivate::swap()
 {
     qSwap( mWidth, mHeight );
 }
 
 class Okular::ExportFormatPrivate : public QSharedData
 {
     public:
         ExportFormatPrivate( const QString &description, const QMimeType &mimeType, const QIcon &icon = QIcon() )
             : QSharedData(), mDescription( description ), mMimeType( mimeType ), mIcon( icon )
         {
         }
         ~ExportFormatPrivate()
         {
         }
 
         QString mDescription;
         QMimeType mMimeType;
         QIcon mIcon;
 };
 
 ExportFormat::ExportFormat()
     : d( new ExportFormatPrivate( QString(), QMimeType() ) )
 {
 }
 
 ExportFormat::ExportFormat( const QString &description, const QMimeType &mimeType )
     : d( new ExportFormatPrivate( description, mimeType ) )
 {
 }
 
 ExportFormat::ExportFormat( const QIcon &icon, const QString &description, const QMimeType &mimeType )
     : d( new ExportFormatPrivate( description, mimeType, icon ) )
 {
 }
 
 ExportFormat::~ExportFormat()
 {
 }
 
 ExportFormat::ExportFormat( const ExportFormat &other )
     : d( other.d )
 {
 }
 
 ExportFormat& ExportFormat::operator=( const ExportFormat &other )
 {
     if ( this == &other )
         return *this;
 
     d = other.d;
 
     return *this;
 }
 
 QString ExportFormat::description() const
 {
     return d->mDescription;
 }
 
 QMimeType ExportFormat::mimeType() const
 {
     return d->mMimeType;
 }
 
 QIcon ExportFormat::icon() const
 {
     return d->mIcon;
 }
 
 bool ExportFormat::isNull() const
 {
     return !d->mMimeType.isValid() || d->mDescription.isNull();
 }
 
 ExportFormat ExportFormat::standardFormat( StandardExportFormat type )
 {
     QMimeDatabase db;
     switch ( type )
     {
         case PlainText:
             return ExportFormat( QIcon::fromTheme( QStringLiteral("text-x-generic") ), i18n( "Plain &Text..." ), db.mimeTypeForName( QStringLiteral("text/plain") ) );
             break;
         case PDF:
             return ExportFormat( QIcon::fromTheme( QStringLiteral("application-pdf") ), i18n( "PDF" ), db.mimeTypeForName( QStringLiteral("application/pdf") ) );
             break;
         case OpenDocumentText:
             return ExportFormat(
                 QIcon::fromTheme( QStringLiteral("application-vnd.oasis.opendocument.text") ),
                 i18nc( "This is the document format", "OpenDocument Text" ),
                 db.mimeTypeForName( QStringLiteral("application/vnd.oasis.opendocument.text") ) );
 	    break;
         case HTML:
             return ExportFormat( QIcon::fromTheme( QStringLiteral("text-html") ), i18nc( "This is the document format", "HTML" ), db.mimeTypeForName( QStringLiteral("text/html") ) );
             break;
     }
     return ExportFormat();
 }
 
 bool ExportFormat::operator==( const ExportFormat &other ) const
 {
     return d == other.d;
 }
 
 bool ExportFormat::operator!=( const ExportFormat &other ) const
 {
     return d != other.d;
 }
 
 QDebug operator<<( QDebug str, const Okular::PixmapRequest &req )
 {
     QString s = QStringLiteral( "PixmapRequest(#%2, %1, %3x%4, page %6, prio %5)" )
         .arg( QString( req.asynchronous() ? QStringLiteral ( "async" ) : QStringLiteral ( "sync" ) ) )
         .arg( (qulonglong)req.observer() )
         .arg( req.width() )
         .arg( req.height() )
         .arg( req.priority() )
         .arg( req.pageNumber() );
     str << qPrintable( s );
     return str;
 }
 
 #include "moc_generator.cpp"
 
 /* kate: replace-tabs on; indent-width 4; */
diff --git a/core/generator.h b/core/generator.h
index 91930b925..23bbd5172 100644
--- a/core/generator.h
+++ b/core/generator.h
@@ -1,734 +1,726 @@
 /***************************************************************************
  *   Copyright (C) 2004-5 by Enrico Ros <eros.kde@email.it>                *
  *   Copyright (C) 2005   by Piotr Szymanski <niedakh@gmail.com>           *
  *   Copyright (C) 2008   by Albert Astals Cid <aacid@kde.org>             *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #ifndef _OKULAR_GENERATOR_H_
 #define _OKULAR_GENERATOR_H_
 
 #include "okularcore_export.h"
 #include "document.h"
 #include "fontinfo.h"
 #include "global.h"
 #include "pagesize.h"
 
 #include <QtCore/QList>
 #include <QtCore/QObject>
 #include <QtCore/QSharedDataPointer>
 #include <QtCore/QSizeF>
 #include <QtCore/QString>
 #include <QtCore/QVariant>
 #include <QtCore/QVector>
 
 #include <QMimeType>
 #include <kpluginfactory.h>
 
 #define OKULAR_EXPORT_PLUGIN(classname, json ) \
     static_assert(json[0] != '\0', "arg2 must be a string literal"); \
     K_PLUGIN_FACTORY_WITH_JSON(classname ## Factory, json, registerPlugin<classname >();)
 
 class QByteArray;
 class QMutex;
 class QPrinter;
 class QPrintDialog;
 class QIcon;
 
 namespace Okular {
 
 class BackendOpaqueAction;
 class DocumentFonts;
 class DocumentInfo;
 class DocumentObserver;
 class DocumentSynopsis;
 class EmbeddedFile;
 class ExportFormatPrivate;
 class FontInfo;
 class GeneratorPrivate;
 class Page;
 class PixmapRequest;
 class PixmapRequestPrivate;
 class TextPage;
 class NormalizedRect;
 class SourceReference;
 
 /* Note: on contents generation and asynchronous queries.
  * Many observers may want to request data syncronously or asynchronously.
  * - Sync requests. These should be done in-place.
  * - Async request must be done in real background. That usually means a
  *   thread, such as QThread derived classes.
  * Once contents are available, they must be immediately stored in the
  * Page they refer to, and a signal is emitted as soon as storing
  * (even for sync or async queries) has been done.
  */
 
 /**
  * @short Defines an entry for the export menu
  *
  * This class encapsulates information about an export format.
  * Every Generator can support 0 or more export formats which can be
  * queried with @ref Generator::exportFormats().
  */
 class OKULARCORE_EXPORT ExportFormat
 {
     public:
         typedef QList<ExportFormat> List;
 
         /**
          * Creates an empty export format.
          *
          * @see isNull()
          */
         ExportFormat();
 
         /**
          * Creates a new export format.
          *
          * @param description The i18n'ed description of the format.
          * @param mimeType The supported mime type of the format.
          */
         ExportFormat( const QString &description, const QMimeType &mimeType );
 
         /**
          * Creates a new export format.
          *
          * @param icon The icon used in the GUI for this format.
          * @param description The i18n'ed description of the format.
          * @param mimeType The supported mime type of the format.
          */
         ExportFormat( const QIcon &icon, const QString &description, const QMimeType &mimeType );
 
         /**
          * Destroys the export format.
          */
         ~ExportFormat();
 
         /**
          * @internal
          */
         ExportFormat( const ExportFormat &other );
 
         /**
          * @internal
          */
         ExportFormat& operator=( const ExportFormat &other );
 
         /**
          * Returns the description of the format.
          */
         QString description() const;
 
         /**
          * Returns the mime type of the format.
          */
         QMimeType mimeType() const;
 
         /**
          * Returns the icon for GUI representations of the format.
          */
         QIcon icon() const;
 
         /**
          * Returns whether the export format is null/valid.
          *
          * An ExportFormat is null if the mimetype is not valid or the
          * description is empty, or both.
          */
         bool isNull() const;
 
         /**
          * Type of standard export format.
          */
         enum StandardExportFormat
         {
             PlainText,         ///< Plain text
             PDF,               ///< PDF, aka Portable Document Format
             OpenDocumentText,  ///< OpenDocument Text format @since 0.8 (KDE 4.2)
             HTML   ///< OpenDocument Text format @since 0.8 (KDE 4.2)
         };
 
         /**
          * Builds a standard format for the specified @p type .
          */
         static ExportFormat standardFormat( StandardExportFormat type );
 
         bool operator==( const ExportFormat &other ) const;
 
         bool operator!=( const ExportFormat &other ) const;
 
     private:
         /// @cond PRIVATE
         friend class ExportFormatPrivate;
         /// @endcond
         QSharedDataPointer<ExportFormatPrivate> d;
 };
 
 /**
  * @short [Abstract Class] The information generator.
  *
  * Most of class members are virtuals and some of them pure virtual. The pure
  * virtuals provide the minimal functionalities for a Generator, that is being
  * able to generate QPixmap for the Page 's of the Document.
  *
  * Implementing the other functions will make the Generator able to provide
  * more contents and/or functionalities (like text extraction).
  *
  * Generation/query is requested by the Document class only, and that
  * class stores the resulting data into Page s. The data will then be
  * displayed by the GUI components (PageView, ThumbnailList, etc..).
  *
  * @see PrintInterface, ConfigInterface, GuiInterface
  */
 class OKULARCORE_EXPORT Generator : public QObject
 {
     /// @cond PRIVATE
     friend class PixmapGenerationThread;
     friend class TextPageGenerationThread;
     /// @endcond
 
     Q_OBJECT
 
     public:
         /**
          * Describe the possible optional features that a Generator can
          * provide.
          */
         enum GeneratorFeature
         {
             Threaded,
             TextExtraction,    ///< Whether the Generator can extract text from the document in the form of TextPage's
             ReadRawData,       ///< Whether the Generator can read a document directly from its raw data.
             FontInfo,          ///< Whether the Generator can provide information about the fonts used in the document
             PageSizes,         ///< Whether the Generator can change the size of the document pages.
             PrintNative,       ///< Whether the Generator supports native cross-platform printing (QPainter-based).
             PrintPostscript,   ///< Whether the Generator supports postscript-based file printing.
             PrintToFile,       ///< Whether the Generator supports export to PDF & PS through the Print Dialog
             TiledRendering     ///< Whether the Generator can render tiles @since 0.16 (KDE 4.10)
         };
 
         /**
          * Creates a new generator.
          */
         Generator(QObject* parent = nullptr, const QVariantList& args = QVariantList());
 
         /**
          * Destroys the generator.
          */
         virtual ~Generator();
 
         /**
          * Loads the document with the given @p fileName and fills the
          * @p pagesVector with the parsed pages.
          *
          * @note If you implement the WithPassword variants you don't need to implement this one
          *
          * @returns true on success, false otherwise.
          */
         virtual bool loadDocument( const QString & fileName, QVector< Page * > & pagesVector );
 
         /**
          * Loads the document from the raw data @p fileData and fills the
          * @p pagesVector with the parsed pages.
          *
          * @note If you implement the WithPassword variants you don't need to implement this one
          *
          * @note the Generator has to have the feature @ref ReadRawData enabled
          *
          * @returns true on success, false otherwise.
          */
         virtual bool loadDocumentFromData( const QByteArray & fileData, QVector< Page * > & pagesVector );
 
         /**
          * Loads the document with the given @p fileName and @p password and fills the
          * @p pagesVector with the parsed pages.
          *
          * @note Do not implement this if your format doesn't support passwords, it'll cleanly call loadDocument()
          *
          * @since 0.20 (KDE 4.14)
          *
          * @returns a LoadResult defining the result of the operation
          */
         virtual Document::OpenResult loadDocumentWithPassword( const QString & fileName, QVector< Page * > & pagesVector, const QString &password );
 
         /**
          * Loads the document from the raw data @p fileData and @p password and fills the
          * @p pagesVector with the parsed pages.
          *
          * @note Do not implement this if your format doesn't support passwords, it'll cleanly call loadDocumentFromData()
          *
          * @note the Generator has to have the feature @ref ReadRawData enabled
          *
          * @since 0.20 (KDE 4.14)
          *
          * @returns a LoadResult defining the result of the operation
          */
         virtual Document::OpenResult loadDocumentFromDataWithPassword( const QByteArray & fileData, QVector< Page * > & pagesVector, const QString &password );
 
 
         /**
          * This method is called when the document is closed and not used
          * any longer.
          *
          * @returns true on success, false otherwise.
          */
         bool closeDocument();
 
         /**
          * This method returns whether the generator is ready to
          * handle a new pixmap request.
          */
         virtual bool canGeneratePixmap() const;
 
         /**
          * This method can be called to trigger the generation of
          * a new pixmap as described by @p request.
          */
         virtual void generatePixmap( PixmapRequest * request );
 
         /**
          * This method returns whether the generator is ready to
          * handle a new text page request.
          */
         virtual bool canGenerateTextPage() const;
 
         /**
          * This method can be called to trigger the generation of
          * a text page for the given @p page.
          *
          * The generation is done synchronous or asynchronous, depending
          * on the @p type parameter and the capabilities of the
          * generator (e.g. multithreading).
          *
          * @see TextPage
          */
         virtual void generateTextPage( Page * page );
 
         /**
          * Returns the general information object of the document.
          *
          * Changed signature in okular version 0.21
          */
         virtual DocumentInfo generateDocumentInfo( const QSet<DocumentInfo::Key> &keys ) const;
 
         /**
          * Returns the 'table of content' object of the document or 0 if
          * no table of content is available.
          */
         virtual const DocumentSynopsis * generateDocumentSynopsis();
 
         /**
          * Returns the 'list of embedded fonts' object of the specified \page
          * of the document.
          *
          * \param page a page of the document, starting from 0 - -1 indicates all
          * the other fonts
          */
         virtual FontInfo::List fontsForPage( int page );
 
         /**
          * Returns the 'list of embedded files' object of the document or 0 if
          * no list of embedded files is available.
          */
         virtual const QList<EmbeddedFile*> * embeddedFiles() const;
 
         /**
          * This enum identifies the metric of the page size.
          */
         enum PageSizeMetric
         {
           None,   ///< The page size is not defined in a physical metric.
           Points, ///< The page size is given in 1/72 inches.
           Pixels  ///< The page size is given in screen pixels @since 0.19 (KDE 4.13)
         };
 
         /**
          * This method returns the metric of the page size. Default is @ref None.
          */
         virtual PageSizeMetric pagesSizeMetric() const;
 
         /**
          * This method returns whether given @p action (@ref Permission) is
          * allowed in this document.
          */
         virtual bool isAllowed( Permission action ) const;
 
         /**
          * This method is called when the orientation has been changed by the user.
          */
         virtual void rotationChanged( Rotation orientation, Rotation oldOrientation );
 
         /**
          * Returns the list of supported page sizes.
          */
         virtual PageSize::List pageSizes() const;
 
         /**
          * This method is called when the page size has been changed by the user.
          */
         virtual void pageSizeChanged( const PageSize &pageSize, const PageSize &oldPageSize );
 
         /**
          * This method is called to print the document to the given @p printer.
          */
         virtual bool print( QPrinter &printer );
 
         /**
          * Possible print errors
          * @since 0.11 (KDE 4.5)
          */
         enum PrintError
         {
             NoPrintError,                       ///< There was no print error
             UnknownPrintError,
             TemporaryFileOpenPrintError,
             FileConversionPrintError,
             PrintingProcessCrashPrintError,
             PrintingProcessStartPrintError,
             PrintToFilePrintError,
             InvalidPrinterStatePrintError,
             UnableToFindFilePrintError,
             NoFileToPrintError,
             NoBinaryToPrintError,
             InvalidPageSizePrintError ///< @since 0.18.2 (KDE 4.12.2)
         };
         
         /**
          * This method returns the meta data of the given @p key with the given @p option
          * of the document.
          */
         virtual QVariant metaData( const QString &key, const QVariant &option ) const;
 
         /**
          * Returns the list of additional supported export formats.
          */
         virtual ExportFormat::List exportFormats() const;
 
         /**
          * This method is called to export the document in the given @p format and save it
          * under the given @p fileName. The format must be one of the supported export formats.
          */
         virtual bool exportTo( const QString &fileName, const ExportFormat &format );
 
         /**
          * This method is called to know which wallet data should be used for the given file name.
          * Unless you have very special requirements to where wallet data should be stored you
          * don't need to reimplement this method.
          */
         virtual void walletDataForFile( const QString &fileName, QString *walletName, QString *walletFolder, QString *walletKey ) const;
 
         /**
          * Query for the specified @p feature.
          */
         bool hasFeature( GeneratorFeature feature ) const;
 
         /**
          * Update DPI of the generator
          *
          * @since 0.19 (KDE 4.13)
          */
         void setDPI(const QSizeF &dpi);
 
         /**
          * Returns the 'layers model' object of the document or NULL if
          * layers model is not available.
          *
          * @since 0.24
          */
         virtual QAbstractItemModel * layersModel() const;
 
         /**
          * Calls the backend to execute an BackendOpaqueAction
          */
         virtual void opaqueAction( const BackendOpaqueAction *action );
 
     Q_SIGNALS:
         /**
          * This signal should be emitted whenever an error occurred in the generator.
          *
          * @param message The message which should be shown to the user.
          * @param duration The time that the message should be shown to the user.
          */
         void error( const QString &message, int duration );
 
         /**
          * This signal should be emitted whenever the user should be warned.
          *
          * @param message The message which should be shown to the user.
          * @param duration The time that the message should be shown to the user.
          */
         void warning( const QString &message, int duration );
 
         /**
          * This signal should be emitted whenever the user should be noticed.
          *
          * @param message The message which should be shown to the user.
          * @param duration The time that the message should be shown to the user.
          */
         void notice( const QString &message, int duration );
 
     protected:
         /**
          * This method must be called when the pixmap request triggered by generatePixmap()
          * has been finished.
          */
         void signalPixmapRequestDone( PixmapRequest * request );
 
         /**
          * This method must be called when a text generation has been finished.
          */
         void signalTextGenerationDone( Page *page, TextPage *textPage );
 
         /**
          * This method is called when the document is closed and not used
          * any longer.
          *
          * @returns true on success, false otherwise.
          */
         virtual bool doCloseDocument() = 0;
 
         /**
          * Returns the image of the page as specified in
          * the passed pixmap @p request.
          *
          * @warning this method may be executed in its own separated thread if the
          * @ref Threaded is enabled!
          */
         virtual QImage image( PixmapRequest *page );
 
         /**
          * Returns the text page for the given @p page.
          *
          * @warning this method may be executed in its own separated thread if the
          * @ref Threaded is enabled!
          */
         virtual TextPage* textPage( Page *page );
 
         /**
          * Returns a pointer to the document.
          */
         const Document * document() const;
 
         /**
          * Toggle the @p feature .
          */
         void setFeature( GeneratorFeature feature, bool on = true );
 
         /**
          * Internal document setting
          */
         enum DocumentMetaDataKey {
             PaperColorMetaData,         ///< Returns (QColor) the paper color if set in Settings or the default color (white) if option is true (otherwise returns a non initialized QColor)
             TextAntialiasMetaData,      ///< Returns (bool) text antialias from Settings (option is not used)
             GraphicsAntialiasMetaData,  ///< Returns (bool)graphic antialias from Settings (option is not used)
             TextHintingMetaData         ///< Returns (bool)text hinting from Settings (option is not used)
         };
 
         /**
          * Request a meta data of the Document, if available, like an internal
          * setting.
          *
          * @since 1.1
          */
         QVariant documentMetaData( const DocumentMetaDataKey key, const QVariant &option = QVariant() ) const;
 
         /**
          * Request a meta data of the Document, if available, like an internal
          * setting.
          */
         OKULARCORE_DEPRECATED QVariant documentMetaData( const QString &key, const QVariant &option = QVariant() ) const;
 
         /**
          * Return the pointer to a mutex the generator can use freely.
          */
         QMutex* userMutex() const;
 
         /**
          * Set the bounding box of a page after the page has already been handed
          * to the Document. Call this instead of Page::setBoundingBox() to ensure
          * that all observers are notified.
          *
          * @since 0.7 (KDE 4.1)
          */
         void updatePageBoundingBox( int page, const NormalizedRect & boundingBox );
 
         /**
          * Returns DPI, previously set via setDPI()
          * @since 0.19 (KDE 4.13)
          */
         QSizeF dpi() const;
 
     protected Q_SLOTS:
         /**
          * Gets the font data for the given font
          *
          * @since 0.8 (KDE 4.1)
          */
         void requestFontData(const Okular::FontInfo &font, QByteArray *data);
 
         /**
          * Returns the last print error in case print() failed
          * @since 0.11 (KDE 4.5)
          */
         Okular::Generator::PrintError printError() const;
 
     protected:
         /// @cond PRIVATE
         Generator(GeneratorPrivate &dd, QObject *parent, const QVariantList &args);
         Q_DECLARE_PRIVATE( Generator )
         GeneratorPrivate *d_ptr;
 
         friend class Document;
         friend class DocumentPrivate;
         /// @endcond PRIVATE
 
     private:
         Q_DISABLE_COPY( Generator )
 
         Q_PRIVATE_SLOT( d_func(), void pixmapGenerationFinished() )
         Q_PRIVATE_SLOT( d_func(), void textpageGenerationFinished() )
 };
 
 /**
  * @short Describes a pixmap type request.
  */
 class OKULARCORE_EXPORT PixmapRequest
 {
     friend class Document;
     friend class DocumentPrivate;
 
     public:
         enum PixmapRequestFeature
         {
             NoFeature = 0,
             Asynchronous = 1,
             Preload = 2
         };
         Q_DECLARE_FLAGS( PixmapRequestFeatures, PixmapRequestFeature )
 
         /**
          * Creates a new pixmap request.
          *
          * @param observer The observer.
          * @param pageNumber The page number.
          * @param width The width of the page.
          * @param height The height of the page.
-         * @param dpr The device pixel ratio of the page.
          * @param priority The priority of the request.
          * @param features The features of generation.
          */
-        PixmapRequest( DocumentObserver *observer, int pageNumber, int width, int height, qreal dpr, int priority, PixmapRequestFeatures features );
+        PixmapRequest( DocumentObserver *observer, int pageNumber, int width, int height, int priority, PixmapRequestFeatures features );
 
         /**
          * Destroys the pixmap request.
          */
         ~PixmapRequest();
 
         /**
          * Returns the observer of the request.
          */
         DocumentObserver *observer() const;
 
         /**
          * Returns the page number of the request.
          */
         int pageNumber() const;
 
         /**
          * Returns the page width of the requested pixmap.
          */
         int width() const;
 
         /**
          * Returns the page height of the requested pixmap.
          */
         int height() const;
 
-        /**
-         * Returns the device pixel ratio of the requested pixmap.
-         *
-         * @since 1.2
-         */
-        qreal devicePixelRatio() const;
-
         /**
          * Returns the priority (less it better, 0 is maximum) of the
          * request.
          */
         int priority() const;
 
         /**
          * Returns whether the generation should be done synchronous or
          * asynchronous.
          *
          * If asynchronous, the pixmap is created in a thread and the observer
          * is notified when the job is done.
          */
         bool asynchronous() const;
 
         /**
          * Returns whether the generation request is for a page that is not important
          * i.e. it's just for speeding up future rendering
          */
         bool preload() const;
 
         /**
          * Returns a pointer to the page where the pixmap shall be generated for.
          */
         Page *page() const;
 
         /**
          * Sets whether the generator should render only the given normalized
          * rect or the entire page
          *
          * @since 0.16 (KDE 4.10)
          */
         void setTile( bool tile );
 
         /**
          * Returns whether the generator should render just the region given by
          * normalizedRect() or the entire page.
          *
          * @since 0.16 (KDE 4.10)
          */
         bool isTile() const;
 
         /**
          * Sets the region of the page to request.
          *
          * @since 0.16 (KDE 4.10)
          */
         void setNormalizedRect( const NormalizedRect &rect );
 
         /**
          * Returns the normalized region of the page to request.
          *
          * @since 0.16 (KDE 4.10)
          */
         const NormalizedRect& normalizedRect() const;
 
     private:
         Q_DISABLE_COPY( PixmapRequest )
 
         friend class PixmapRequestPrivate;
         PixmapRequestPrivate* const d;
 };
 
 }
 
 Q_DECLARE_METATYPE(Okular::Generator::PrintError)
 
 #define OkularGeneratorInterface_iid "org.kde.okular.Generator"
 Q_DECLARE_INTERFACE(Okular::Generator, OkularGeneratorInterface_iid)
 
 #ifndef QT_NO_DEBUG_STREAM
 OKULARCORE_EXPORT QDebug operator<<( QDebug str, const Okular::PixmapRequest &req );
 #endif
 
 #endif
 
 /* kate: replace-tabs on; indent-width 4; */
diff --git a/core/generator_p.h b/core/generator_p.h
index da48c37f4..060bc135d 100644
--- a/core/generator_p.h
+++ b/core/generator_p.h
@@ -1,170 +1,169 @@
 /***************************************************************************
  *   Copyright (C) 2007  Tobias Koenig <tokoe@kde.org>                     *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #ifndef OKULAR_THREADEDGENERATOR_P_H
 #define OKULAR_THREADEDGENERATOR_P_H
 
 #include "area.h"
 
 #include <QtCore/QSet>
 #include <QtCore/QThread>
 #include <QtGui/QImage>
 
 class QEventLoop;
 class QMutex;
 
 namespace Okular {
 
 class DocumentObserver;
 class DocumentPrivate;
 class FontInfo;
 class Generator;
 class Page;
 class PixmapGenerationThread;
 class PixmapRequest;
 class TextPage;
 class TextPageGenerationThread;
 class TilesManager;
 
 class GeneratorPrivate
 {
     public:
         GeneratorPrivate();
 
         virtual ~GeneratorPrivate();
 
         Q_DECLARE_PUBLIC( Generator )
         Generator *q_ptr;
 
         PixmapGenerationThread* pixmapGenerationThread();
         TextPageGenerationThread* textPageGenerationThread();
 
         void pixmapGenerationFinished();
         void textpageGenerationFinished();
 
         QMutex* threadsLock();
 
         virtual QVariant metaData( const QString &key, const QVariant &option ) const;
         virtual QImage image( PixmapRequest * );
 
         DocumentPrivate *m_document;
         // NOTE: the following should be a QSet< GeneratorFeature >,
         // but it is not to avoid #include'ing generator.h
         QSet< int > m_features;
         PixmapGenerationThread *mPixmapGenerationThread;
         TextPageGenerationThread *mTextPageGenerationThread;
         mutable QMutex *m_mutex;
         QMutex *m_threadsMutex;
         bool mPixmapReady : 1;
         bool mTextPageReady : 1;
         bool m_closing : 1;
         QEventLoop *m_closingLoop;
         QSizeF m_dpi;
 };
 
 
 class PixmapRequestPrivate
 {
     public:
         void swap();
         TilesManager *tilesManager() const;
 
         DocumentObserver *mObserver;
         int mPageNumber;
         int mWidth;
         int mHeight;
-        qreal mDpr;
         int mPriority;
         int mFeatures;
         bool mForce : 1;
         bool mTile : 1;
         Page *mPage;
         NormalizedRect mNormalizedRect;
 };
 
 
 class PixmapGenerationThread : public QThread
 {
     Q_OBJECT
 
     public:
         PixmapGenerationThread( Generator *generator );
 
         void startGeneration( PixmapRequest *request, bool calcBoundingRect );
 
         void endGeneration();
 
         PixmapRequest *request() const;
 
         QImage image() const;
         bool calcBoundingBox() const;
         NormalizedRect boundingBox() const;
 
     protected:
         void run() override;
 
     private:
         Generator *mGenerator;
         PixmapRequest *mRequest;
         QImage mImage;
         NormalizedRect mBoundingBox;
         bool mCalcBoundingBox : 1;
 };
 
 
 class TextPageGenerationThread : public QThread
 {
     Q_OBJECT
 
     public:
         TextPageGenerationThread( Generator *generator );
 
         void startGeneration( Page *page );
 
         void endGeneration();
 
         Page *page() const;
 
         TextPage* textPage() const;
 
     protected:
         void run() override;
 
     private:
         Generator *mGenerator;
         Page *mPage;
         TextPage *mTextPage;
 };
 
 class FontExtractionThread : public QThread
 {
     Q_OBJECT
 
     public:
         FontExtractionThread( Generator *generator, int pages );
 
         void startExtraction( bool async );
         void stopExtraction();
 
     Q_SIGNALS:
         void gotFont( const Okular::FontInfo& );
         void progress( int page );
 
     protected:
         void run() override;
 
     private:
         Generator *mGenerator;
         int mNumOfPages;
         bool mGoOn;
 };
 
 }
 
 #endif
diff --git a/core/page.cpp b/core/page.cpp
index 74b7ed0fa..3478769ea 100644
--- a/core/page.cpp
+++ b/core/page.cpp
@@ -1,1024 +1,1022 @@
 /***************************************************************************
  *   Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>                  *
  *   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.                                   *
  ***************************************************************************/
 
 #include "page.h"
 #include "page_p.h"
 
 // qt/kde includes
 #include <QtCore/QHash>
 #include <QtCore/QSet>
 #include <QtCore/QString>
 #include <QtCore/QVariant>
 #include <QtCore/QUuid>
 #include <QtGui/QPixmap>
 #include <QtXml/QDomDocument>
 #include <QtXml/QDomElement>
 
 #include <QtCore/QDebug>
 
 // local includes
 #include "action.h"
 #include "annotations.h"
 #include "annotations_p.h"
 #include "area.h"
 #include "debug_p.h"
 #include "document.h"
 #include "document_p.h"
 #include "form.h"
 #include "form_p.h"
 #include "observer.h"
 #include "pagecontroller_p.h"
 #include "pagesize.h"
 #include "pagetransition.h"
 #include "rotationjob_p.h"
 #include "textpage.h"
 #include "textpage_p.h"
 #include "tile.h"
 #include "tilesmanager_p.h"
 #include "utils_p.h"
 
 #include <limits>
 
 #ifdef PAGE_PROFILE
 #include <QtCore/QTime>
 #endif
 
 using namespace Okular;
 
 static const double distanceConsideredEqual = 25; // 5px
 
 static void deleteObjectRects( QLinkedList< ObjectRect * >& rects, const QSet<ObjectRect::ObjectType>& which )
 {
     QLinkedList< ObjectRect * >::iterator it = rects.begin(), end = rects.end();
     for ( ; it != end; )
         if ( which.contains( (*it)->objectType() ) )
         {
             delete *it;
             it = rects.erase( it );
         }
         else
             ++it;
 }
 
 PagePrivate::PagePrivate( Page *page, uint n, double w, double h, Rotation o )
     : m_page( page ), m_number( n ), m_orientation( o ),
       m_width( w ), m_height( h ), m_doc( 0 ), m_boundingBox( 0, 0, 1, 1 ),
       m_rotation( Rotation0 ),
       m_text( 0 ), m_transition( 0 ), m_textSelections( 0 ),
       m_openingAction( 0 ), m_closingAction( 0 ), m_duration( -1 ),
       m_isBoundingBoxKnown( false )
 {
     // avoid Division-By-Zero problems in the program
     if ( m_width <= 0 )
         m_width = 1;
 
     if ( m_height <= 0 )
         m_height = 1;
 }
 
 PagePrivate::~PagePrivate()
 {
     qDeleteAll( formfields );
     delete m_openingAction;
     delete m_closingAction;
     delete m_text;
     delete m_transition;
 }
 
 PagePrivate *PagePrivate::get( Page * page )
 {
     return page->d;
 }
 
 void PagePrivate::imageRotationDone( RotationJob * job )
 {
     TilesManager *tm = tilesManager( job->observer() );
     if ( tm )
     {
         QPixmap *pixmap = new QPixmap( QPixmap::fromImage( job->image() ) );
         tm->setPixmap( pixmap, job->rect() );
         delete pixmap;
         return;
     }
 
     QMap< DocumentObserver*, PixmapObject >::iterator it = m_pixmaps.find( job->observer() );
     if ( it != m_pixmaps.end() )
     {
         PixmapObject &object = it.value();
         (*object.m_pixmap) = QPixmap::fromImage( job->image() );
         object.m_rotation = job->rotation();
     } else {
         PixmapObject object;
         object.m_pixmap = new QPixmap( QPixmap::fromImage( job->image() ) );
         object.m_rotation = job->rotation();
 
         m_pixmaps.insert( job->observer(), object );
     }
 }
 
 QTransform PagePrivate::rotationMatrix() const
 {
     return Okular::buildRotationMatrix( m_rotation );
 }
 
 /** class Page **/
 
 Page::Page( uint page, double w, double h, Rotation o )
     : d( new PagePrivate( this, page, w, h, o ) )
 {
 }
 
 Page::~Page()
 {
     deletePixmaps();
     deleteRects();
     d->deleteHighlights();
     deleteAnnotations();
     d->deleteTextSelections();
     deleteSourceReferences();
 
     delete d;
 }
 
 int Page::number() const
 {
     return d->m_number;
 }
 
 Rotation Page::orientation() const
 {
     return d->m_orientation;
 }
 
 Rotation Page::rotation() const
 {
     return d->m_rotation;
 }
 
 Rotation Page::totalOrientation() const
 {
     return (Rotation)( ( (int)d->m_orientation + (int)d->m_rotation ) % 4 );
 }
 
 double Page::width() const
 {
     return d->m_width;
 }
 
 double Page::height() const
 {
     return d->m_height;
 }
 
 double Page::ratio() const
 {
     return d->m_height / d->m_width;
 }
 
 NormalizedRect Page::boundingBox() const
 {
     return d->m_boundingBox;
 }
 
 bool Page::isBoundingBoxKnown() const
 {
     return d->m_isBoundingBoxKnown;
 }
 
 void Page::setBoundingBox( const NormalizedRect& bbox )
 {
     if ( d->m_isBoundingBoxKnown && d->m_boundingBox == bbox )
         return;
 
     // Allow tiny rounding errors (happens during rotation)
     static const double epsilon = 0.00001;
     Q_ASSERT( bbox.left >= -epsilon && bbox.top >= -epsilon && bbox.right <= 1 + epsilon && bbox.bottom <= 1 + epsilon );
 
     d->m_boundingBox = bbox & NormalizedRect( 0., 0., 1., 1. );
     d->m_isBoundingBoxKnown = true;
 }
 
 bool Page::hasPixmap( DocumentObserver *observer, int width, int height, const NormalizedRect &rect ) const
 {
     TilesManager *tm = d->tilesManager( observer );
     if ( tm )
     {
         if ( width != tm->width() || height != tm->height() )
         {
             tm->setSize( width, height );
             return false;
         }
 
         return tm->hasPixmap( rect );
     }
 
     QMap< DocumentObserver*, PagePrivate::PixmapObject >::const_iterator it = d->m_pixmaps.constFind( observer );
     if ( it == d->m_pixmaps.constEnd() )
         return false;
 
     if ( width == -1 || height == -1 )
         return true;
 
     const QPixmap *pixmap = it.value().m_pixmap;
 
     return (pixmap->width() == width && pixmap->height() == height);
 }
 
 bool Page::hasTextPage() const
 {
     return d->m_text != 0;
 }
 
 RegularAreaRect * Page::wordAt( const NormalizedPoint &p, QString *word ) const
 {
     if ( d->m_text )
         return d->m_text->wordAt( p, word );
 
     return 0;
 }
 
 RegularAreaRect * Page::textArea ( TextSelection * selection ) const
 {
     if ( d->m_text )
         return d->m_text->textArea( selection );
 
     return 0;
 }
 
 bool Page::hasObjectRect( double x, double y, double xScale, double yScale ) const
 {
     if ( m_rects.isEmpty() )
         return false;
 
     QLinkedList< ObjectRect * >::const_iterator it = m_rects.begin(), end = m_rects.end();
     for ( ; it != end; ++it )
         if ( (*it)->distanceSqr( x, y, xScale, yScale ) < distanceConsideredEqual )
             return true;
 
     return false;
 }
 
 bool Page::hasHighlights( int s_id ) const
 {
     // simple case: have no highlights
     if ( m_highlights.isEmpty() )
         return false;
     // simple case: we have highlights and no id to match
     if ( s_id == -1 )
         return true;
     // iterate on the highlights list to find an entry by id
     QLinkedList< HighlightAreaRect * >::const_iterator it = m_highlights.begin(), end = m_highlights.end();
     for ( ; it != end; ++it )
         if ( (*it)->s_id == s_id )
             return true;
     return false;
 }
 
 bool Page::hasTransition() const
 {
     return d->m_transition != 0;
 }
 
 bool Page::hasAnnotations() const
 {
     return !m_annotations.isEmpty();
 }
 
 RegularAreaRect * Page::findText( int id, const QString & text, SearchDirection direction,
                                   Qt::CaseSensitivity caseSensitivity, const RegularAreaRect *lastRect ) const
 {
     RegularAreaRect* rect = 0;
     if ( text.isEmpty() || !d->m_text )
         return rect;
 
     rect = d->m_text->findText( id, text, direction, caseSensitivity, lastRect );
     return rect;
 }
 
 QString Page::text( const RegularAreaRect * area ) const
 {
     return text( area, TextPage::AnyPixelTextAreaInclusionBehaviour );
 }
 
 QString Page::text( const RegularAreaRect * area, TextPage::TextAreaInclusionBehaviour b ) const
 {
     QString ret;
 
     if ( !d->m_text )
         return ret;
 
     if ( area )
     {
         RegularAreaRect rotatedArea = *area;
         rotatedArea.transform( d->rotationMatrix().inverted() );
 
         ret = d->m_text->text( &rotatedArea, b );
     }
     else
         ret = d->m_text->text( 0, b );
 
     return ret;
 }
 
 TextEntity::List Page::words( const RegularAreaRect * area, TextPage::TextAreaInclusionBehaviour b ) const
 {
     TextEntity::List ret;
 
     if ( !d->m_text )
         return ret;
 
     if ( area )
     {
         RegularAreaRect rotatedArea = *area;
         rotatedArea.transform( d->rotationMatrix().inverted() );
 
         ret = d->m_text->words( &rotatedArea, b );
     }
     else
         ret = d->m_text->words( 0, b );
 
     for (int i = 0; i < ret.length(); ++i)
     {
         const TextEntity * orig = ret[i];
         ret[i] = new TextEntity( orig->text(), new Okular::NormalizedRect(orig->transformedArea ( d->rotationMatrix() )) );
         delete orig;
     }
 
     return ret;
 }
 
 void PagePrivate::rotateAt( Rotation orientation )
 {
     if ( orientation == m_rotation )
         return;
 
     deleteHighlights();
     deleteTextSelections();
 
     if ( ( (int)m_orientation + (int)m_rotation ) % 2 != ( (int)m_orientation + (int)orientation ) % 2 )
         qSwap( m_width, m_height );
 
     Rotation oldRotation = m_rotation;
     m_rotation = orientation;
 
     /**
      * Rotate the images of the page.
      */
     QMapIterator< DocumentObserver*, PagePrivate::PixmapObject > it( m_pixmaps );
     while ( it.hasNext() ) {
         it.next();
 
         const PagePrivate::PixmapObject &object = it.value();
 
         RotationJob *job = new RotationJob( object.m_pixmap->toImage(), object.m_rotation, m_rotation, it.key() );
         job->setPage( this );
         m_doc->m_pageController->addRotationJob(job);
     }
 
     /**
      * Rotate tiles manager
      */
     QMapIterator<const DocumentObserver *, TilesManager *> i(m_tilesManagers);
     while (i.hasNext()) {
       i.next();
 
       TilesManager *tm = i.value();
       if ( tm )
         tm->setRotation( m_rotation );
     }
 
     /**
      * Rotate the object rects on the page.
      */
     const QTransform matrix = rotationMatrix();
     QLinkedList< ObjectRect * >::const_iterator objectIt = m_page->m_rects.begin(), end = m_page->m_rects.end();
     for ( ; objectIt != end; ++objectIt )
         (*objectIt)->transform( matrix );
 
     QLinkedList< HighlightAreaRect* >::const_iterator hlIt = m_page->m_highlights.begin(), hlItEnd = m_page->m_highlights.end();
     for ( ; hlIt != hlItEnd; ++hlIt )
     {
         (*hlIt)->transform( RotationJob::rotationMatrix( oldRotation, m_rotation ) );
     }
 }
 
 void PagePrivate::changeSize( const PageSize &size )
 {
     if ( size.isNull() || ( size.width() == m_width && size.height() == m_height ) )
         return;
 
     m_page->deletePixmaps();
 //    deleteHighlights();
 //    deleteTextSelections();
 
     m_width = size.width();
     m_height = size.height();
     if ( m_rotation % 2 )
         qSwap( m_width, m_height );
 }
 
 const ObjectRect * Page::objectRect( ObjectRect::ObjectType type, double x, double y, double xScale, double yScale ) const
 {
     // Walk list in reverse order so that annotations in the foreground are preferred
     QLinkedListIterator< ObjectRect * > it( m_rects );
     it.toBack();
     while ( it.hasPrevious() )
     {
         const ObjectRect *objrect = it.previous();
         if ( ( objrect->objectType() == type ) && objrect->distanceSqr( x, y, xScale, yScale ) < distanceConsideredEqual )
             return objrect;
     }
 
     return 0;
 }
 
 QLinkedList< const ObjectRect * > Page::objectRects( ObjectRect::ObjectType type, double x, double y, double xScale, double yScale ) const
 {
     QLinkedList< const ObjectRect * > result;
 
     QLinkedListIterator< ObjectRect * > it( m_rects );
     it.toBack();
     while ( it.hasPrevious() )
     {
         const ObjectRect *objrect = it.previous();
         if ( ( objrect->objectType() == type ) && objrect->distanceSqr( x, y, xScale, yScale ) < distanceConsideredEqual )
             result.append( objrect );
     }
 
     return result;
 }
 
 
 const ObjectRect* Page::nearestObjectRect( ObjectRect::ObjectType type, double x, double y, double xScale, double yScale, double * distance ) const
 {
     ObjectRect * res = 0;
     double minDistance = std::numeric_limits<double>::max();
 
     QLinkedList< ObjectRect * >::const_iterator it = m_rects.constBegin(), end = m_rects.constEnd();
     for ( ; it != end; ++it )
     {
         if ( (*it)->objectType() == type )
         {
             double d = (*it)->distanceSqr( x, y, xScale, yScale );
             if ( d < minDistance )
             {
                 res = (*it);
                 minDistance = d;
             }
         }
     }
 
     if ( distance )
         *distance = minDistance;
     return res;
 }
 
 const PageTransition * Page::transition() const
 {
     return d->m_transition;
 }
 
 QLinkedList< Annotation* > Page::annotations() const
 {
     return m_annotations;
 }
 
 const Action * Page::pageAction( PageAction action ) const
 {
     switch ( action )
     {
         case Page::Opening:
             return d->m_openingAction;
             break;
         case Page::Closing:
             return d->m_closingAction;
             break;
     }
 
     return 0;
 }
 
 QLinkedList< FormField * > Page::formFields() const
 {
     return d->formfields;
 }
 
 void Page::setPixmap( DocumentObserver *observer, QPixmap *pixmap, const NormalizedRect &rect )
 {
     if ( d->m_rotation == Rotation0 ) {
         TilesManager *tm = d->tilesManager( observer );
         if ( tm )
         {
             tm->setPixmap( pixmap, rect );
             delete pixmap;
             return;
         }
 
         QMap< DocumentObserver*, PagePrivate::PixmapObject >::iterator it = d->m_pixmaps.find( observer );
         if ( it != d->m_pixmaps.end() )
         {
             delete it.value().m_pixmap;
         }
         else
         {
             it = d->m_pixmaps.insert( observer, PagePrivate::PixmapObject() );
         }
         it.value().m_pixmap = pixmap;
         it.value().m_rotation = d->m_rotation;
     } else {
         RotationJob *job = new RotationJob( pixmap->toImage(), Rotation0, d->m_rotation, observer );
         job->setPage( d );
         job->setRect( TilesManager::toRotatedRect( rect, d->m_rotation ) );
         d->m_doc->m_pageController->addRotationJob(job);
 
         delete pixmap;
     }
 }
 
 void Page::setTextPage( TextPage * textPage )
 {
     delete d->m_text;
 
     d->m_text = textPage;
     if ( d->m_text )
     {
         d->m_text->d->m_page = d;
         /**
          * Correct text order for before text selection
          */
         d->m_text->d->correctTextOrder();
     }
 }
 
 void Page::setObjectRects( const QLinkedList< ObjectRect * > & rects )
 {
     QSet<ObjectRect::ObjectType> which;
     which << ObjectRect::Action << ObjectRect::Image;
     deleteObjectRects( m_rects, which );
 
     /**
      * Rotate the object rects of the page.
      */
     const QTransform matrix = d->rotationMatrix();
 
     QLinkedList< ObjectRect * >::const_iterator objectIt = rects.begin(), end = rects.end();
     for ( ; objectIt != end; ++objectIt )
         (*objectIt)->transform( matrix );
 
     m_rects << rects;
 }
 
 void PagePrivate::setHighlight( int s_id, RegularAreaRect *rect, const QColor & color )
 {
     HighlightAreaRect * hr = new HighlightAreaRect(rect);
     hr->s_id = s_id;
     hr->color = color;
 
     m_page->m_highlights.append( hr );
 }
 
 void PagePrivate::setTextSelections( RegularAreaRect *r, const QColor & color )
 {
     deleteTextSelections();
     if ( r )
     {
         HighlightAreaRect * hr = new HighlightAreaRect( r );
         hr->s_id = -1;
         hr->color = color;
         m_textSelections = hr;
         delete r;
     }
 }
 
 void Page::setSourceReferences( const QLinkedList< SourceRefObjectRect * > & refRects )
 {
     deleteSourceReferences();
     foreach( SourceRefObjectRect * rect, refRects )
         m_rects << rect;
 }
 
 void Page::setDuration( double seconds )
 {
     d->m_duration = seconds;
 }
 
 double Page::duration() const
 {
     return d->m_duration;
 }
 
 void Page::setLabel( const QString& label )
 {
     d->m_label = label;
 }
 
 QString Page::label() const
 {
     return d->m_label;
 }
 
 const RegularAreaRect * Page::textSelection() const
 {
     return d->m_textSelections;
 }
 
 QColor Page::textSelectionColor() const
 {
     return d->m_textSelections ? d->m_textSelections->color : QColor();
 }
 
 void Page::addAnnotation( Annotation * annotation )
 {
     // Generate uniqueName: okular-{UUID}
     if(annotation->uniqueName().isEmpty())
     {
         QString uniqueName = QStringLiteral("okular-") + QUuid::createUuid().toString();
         annotation->setUniqueName( uniqueName );
     }
     annotation->d_ptr->m_page = d;
     m_annotations.append( annotation );
 
     AnnotationObjectRect *rect = new AnnotationObjectRect( annotation );
 
     // Rotate the annotation on the page.
     const QTransform matrix = d->rotationMatrix();
     annotation->d_ptr->annotationTransform( matrix );
 
     m_rects.append( rect );
 }
 
 bool Page::removeAnnotation( Annotation * annotation )
 {
     if ( !d->m_doc->m_parent->canRemovePageAnnotation(annotation) )
         return false;
 
     QLinkedList< Annotation * >::iterator aIt = m_annotations.begin(), aEnd = m_annotations.end();
     for ( ; aIt != aEnd; ++aIt )
     {
         if((*aIt) && (*aIt)->uniqueName()==annotation->uniqueName())
         {
             int rectfound = false;
             QLinkedList< ObjectRect * >::iterator it = m_rects.begin(), end = m_rects.end();
             for ( ; it != end && !rectfound; ++it )
                 if ( ( (*it)->objectType() == ObjectRect::OAnnotation ) && ( (*it)->object() == (*aIt) ) )
                 {
                     delete *it;
                     it = m_rects.erase( it );
                     rectfound = true;
                 }
             qCDebug(OkularCoreDebug) << "removed annotation:" << annotation->uniqueName();
             annotation->d_ptr->m_page = 0;
             m_annotations.erase( aIt );
             break;
         }
     }
 
     return true;
 }
 
 void Page::setTransition( PageTransition * transition )
 {
     delete d->m_transition;
     d->m_transition = transition;
 }
 
 void Page::setPageAction( PageAction action, Action * link )
 {
     switch ( action )
     {
         case Page::Opening:
             delete d->m_openingAction;
             d->m_openingAction = link;
             break;
         case Page::Closing:
             delete d->m_closingAction;
             d->m_closingAction = link;
             break;
     }
 }
 
 void Page::setFormFields( const QLinkedList< FormField * >& fields )
 {
     qDeleteAll( d->formfields );
     d->formfields = fields;
     QLinkedList< FormField * >::const_iterator it = d->formfields.begin(), itEnd = d->formfields.end();
     for ( ; it != itEnd; ++it )
     {
         (*it)->d_ptr->setDefault();
     }
 }
 
 void Page::deletePixmap( DocumentObserver *observer )
 {
     TilesManager *tm = d->tilesManager( observer );
     if ( tm )
     {
         delete tm;
         d->m_tilesManagers.remove(observer);
     }
     else
     {
         PagePrivate::PixmapObject object = d->m_pixmaps.take( observer );
         delete object.m_pixmap;
     }
 }
 
 void Page::deletePixmaps()
 {
     QMapIterator< DocumentObserver*, PagePrivate::PixmapObject > it( d->m_pixmaps );
     while ( it.hasNext() ) {
         it.next();
         delete it.value().m_pixmap;
     }
 
     d->m_pixmaps.clear();
 
     qDeleteAll(d->m_tilesManagers);
     d->m_tilesManagers.clear();
 }
 
 void Page::deleteRects()
 {
     // delete ObjectRects of type Link and Image
     QSet<ObjectRect::ObjectType> which;
     which << ObjectRect::Action << ObjectRect::Image;
     deleteObjectRects( m_rects, which );
 }
 
 void PagePrivate::deleteHighlights( int s_id )
 {
     // delete highlights by ID
     QLinkedList< HighlightAreaRect* >::iterator it = m_page->m_highlights.begin(), end = m_page->m_highlights.end();
     while ( it != end )
     {
         HighlightAreaRect* highlight = *it;
         if ( s_id == -1 || highlight->s_id == s_id )
         {
             it = m_page->m_highlights.erase( it );
             delete highlight;
         }
         else
             ++it;
     }
 }
 
 void PagePrivate::deleteTextSelections()
 {
     delete m_textSelections;
     m_textSelections = 0;
 }
 
 void Page::deleteSourceReferences()
 {
     deleteObjectRects( m_rects, QSet<ObjectRect::ObjectType>() << ObjectRect::SourceRef );
 }
 
 void Page::deleteAnnotations()
 {
     // delete ObjectRects of type Annotation
     deleteObjectRects( m_rects, QSet<ObjectRect::ObjectType>() << ObjectRect::OAnnotation );
     // delete all stored annotations
     QLinkedList< Annotation * >::const_iterator aIt = m_annotations.begin(), aEnd = m_annotations.end();
     for ( ; aIt != aEnd; ++aIt )
         delete *aIt;
     m_annotations.clear();
 }
 
 void PagePrivate::restoreLocalContents( const QDomNode & pageNode )
 {
     // iterate over all chilren (annotationList, ...)
     QDomNode childNode = pageNode.firstChild();
     while ( childNode.isElement() )
     {
         QDomElement childElement = childNode.toElement();
         childNode = childNode.nextSibling();
 
         // parse annotationList child element
         if ( childElement.tagName() == QLatin1String("annotationList") )
         {
 #ifdef PAGE_PROFILE
             QTime time;
             time.start();
 #endif
             // Clone annotationList as root node in restoredLocalAnnotationList
             const QDomNode clonedNode = restoredLocalAnnotationList.importNode( childElement, true );
             restoredLocalAnnotationList.appendChild( clonedNode );
 
             // iterate over all annotations
             QDomNode annotationNode = childElement.firstChild();
             while( annotationNode.isElement() )
             {
                 // get annotation element and advance to next annot
                 QDomElement annotElement = annotationNode.toElement();
                 annotationNode = annotationNode.nextSibling();
 
                 // get annotation from the dom element
                 Annotation * annotation = AnnotationUtils::createAnnotation( annotElement );
 
                 // append annotation to the list or show warning
                 if ( annotation )
                 {
                     m_doc->performAddPageAnnotation(m_number, annotation);
                     qCDebug(OkularCoreDebug) << "restored annot:" << annotation->uniqueName();
                 }
                 else
                     qCWarning(OkularCoreDebug).nospace() << "page (" << m_number << "): can't restore an annotation from XML.";
             }
 #ifdef PAGE_PROFILE
             qCDebug(OkularCoreDebug).nospace() << "annots: XML Load time: " << time.elapsed() << "ms";
 #endif
         }
         // parse formList child element
         else if ( childElement.tagName() == QLatin1String("forms") )
         {
             if ( formfields.isEmpty() )
                 continue;
 
             QHash<int, FormField*> hashedforms;
             QLinkedList< FormField * >::const_iterator fIt = formfields.begin(), fItEnd = formfields.end();
             for ( ; fIt != fItEnd; ++fIt )
             {
                 hashedforms[(*fIt)->id()] = (*fIt);
             }
 
             // iterate over all forms
             QDomNode formsNode = childElement.firstChild();
             while( formsNode.isElement() )
             {
                 // get annotation element and advance to next annot
                 QDomElement formElement = formsNode.toElement();
                 formsNode = formsNode.nextSibling();
 
                 if ( formElement.tagName() != QLatin1String("form") )
                     continue;
 
                 bool ok = true;
                 int index = formElement.attribute( QStringLiteral("id") ).toInt( &ok );
                 if ( !ok )
                     continue;
 
                 QHash<int, FormField*>::const_iterator wantedIt = hashedforms.constFind( index );
                 if ( wantedIt == hashedforms.constEnd() )
                     continue;
 
                 QString value = formElement.attribute( QStringLiteral("value") );
                 (*wantedIt)->d_ptr->setValue( value );
             }
         }
     }
 }
 
 void PagePrivate::saveLocalContents( QDomNode & parentNode, QDomDocument & document, PageItems what ) const
 {
     // create the page node and set the 'number' attribute
     QDomElement pageElement = document.createElement( QStringLiteral("page") );
     pageElement.setAttribute( QStringLiteral("number"), m_number );
 
 #if 0
     // add bookmark info if is bookmarked
     if ( d->m_bookmarked )
     {
         // create the pageElement's 'bookmark' child
         QDomElement bookmarkElement = document.createElement( "bookmark" );
         pageElement.appendChild( bookmarkElement );
 
         // add attributes to the element
         //bookmarkElement.setAttribute( "name", bookmark name );
     }
 #endif
 
     // add annotations info if has got any
     if ( ( what & AnnotationPageItems ) && ( what & OriginalAnnotationPageItems ) )
     {
         const QDomElement savedDocRoot = restoredLocalAnnotationList.documentElement();
         if ( !savedDocRoot.isNull() )
         {
             // Import and append node in target document
             const QDomNode importedNode = document.importNode( savedDocRoot, true );
             pageElement.appendChild( importedNode );
         }
     }
     else if ( ( what & AnnotationPageItems ) && !m_page->m_annotations.isEmpty() )
     {
         // create the annotationList
         QDomElement annotListElement = document.createElement( QStringLiteral("annotationList") );
 
         // add every annotation to the annotationList
         QLinkedList< Annotation * >::const_iterator aIt = m_page->m_annotations.constBegin(), aEnd = m_page->m_annotations.constEnd();
         for ( ; aIt != aEnd; ++aIt )
         {
             // get annotation
             const Annotation * a = *aIt;
             // only save okular annotations (not the embedded in file ones)
             if ( !(a->flags() & Annotation::External) )
             {
                 // append an filled-up element called 'annotation' to the list
                 QDomElement annElement = document.createElement( QStringLiteral("annotation") );
                 AnnotationUtils::storeAnnotation( a, annElement, document );
                 annotListElement.appendChild( annElement );
                 qCDebug(OkularCoreDebug) << "save annotation:" << a->uniqueName();
             }
         }
 
         // append the annotationList element if annotations have been set
         if ( annotListElement.hasChildNodes() )
             pageElement.appendChild( annotListElement );
     }
 
     // add forms info if has got any
     if ( ( what & FormFieldPageItems ) && !formfields.isEmpty() )
     {
         // create the formList
         QDomElement formListElement = document.createElement( QStringLiteral("forms") );
 
         // add every form data to the formList
         QLinkedList< FormField * >::const_iterator fIt = formfields.constBegin(), fItEnd = formfields.constEnd();
         for ( ; fIt != fItEnd; ++fIt )
         {
             // get the form field
             const FormField * f = *fIt;
 
             QString newvalue = f->d_ptr->value();
             if ( f->d_ptr->m_default == newvalue )
                 continue;
 
             // append an filled-up element called 'annotation' to the list
             QDomElement formElement = document.createElement( QStringLiteral("form") );
             formElement.setAttribute( QStringLiteral("id"), f->id() );
             formElement.setAttribute( QStringLiteral("value"), newvalue );
             formListElement.appendChild( formElement );
         }
 
         // append the annotationList element if annotations have been set
         if ( formListElement.hasChildNodes() )
             pageElement.appendChild( formListElement );
     }
 
     // append the page element only if has children
     if ( pageElement.hasChildNodes() )
         parentNode.appendChild( pageElement );
 }
 
-const QPixmap * Page::_o_nearestPixmap( DocumentObserver *observer, int w, int h, qreal dpr ) const
+const QPixmap * Page::_o_nearestPixmap( DocumentObserver *observer, int w, int h ) const
 {
     Q_UNUSED( h )
 
-    QPixmap * pixmap = 0;
+    const QPixmap * pixmap = 0;
 
     // if a pixmap is present for given id, use it
     QMap< DocumentObserver*, PagePrivate::PixmapObject >::const_iterator itPixmap = d->m_pixmaps.constFind( observer );
-    if ( itPixmap != d->m_pixmaps.constEnd() ) {
+    if ( itPixmap != d->m_pixmaps.constEnd() )
         pixmap = itPixmap.value().m_pixmap;
-        //pixmap->setDevicePixelRatio(dpr);
     // else find the closest match using pixmaps of other IDs (great optim!)
-    }
     else if ( !d->m_pixmaps.isEmpty() )
     {
         int minDistance = -1;
         QMap< DocumentObserver*, PagePrivate::PixmapObject >::const_iterator it = d->m_pixmaps.constBegin(), end = d->m_pixmaps.constEnd();
         for ( ; it != end; ++it )
         {
-            int pixWidth = (*it).m_pixmap->width() /*/ (*it).m_pixmap->devicePixelRatioF()*/,
+            int pixWidth = (*it).m_pixmap->width(),
                 distance = pixWidth > w ? pixWidth - w : w - pixWidth;
             if ( minDistance == -1 || distance < minDistance )
             {
                 pixmap = (*it).m_pixmap;
                 minDistance = distance;
             }
         }
     }
 
     return pixmap;
 }
 
 bool Page::hasTilesManager( const DocumentObserver *observer ) const
 {
     return d->tilesManager( observer ) != 0;
 }
 
 QList<Tile> Page::tilesAt( const DocumentObserver *observer, const NormalizedRect &rect ) const
 {
     TilesManager *tm = d->m_tilesManagers.value( observer );
     if ( tm )
         return tm->tilesAt( rect, TilesManager::PixmapTile );
     else
         return QList<Tile>();
 }
 
 TilesManager *PagePrivate::tilesManager( const DocumentObserver *observer ) const
 {
     return m_tilesManagers.value( observer );
 }
 
 void PagePrivate::setTilesManager( const DocumentObserver *observer, TilesManager *tm )
 {
     TilesManager *old = m_tilesManagers.value( observer );
     delete old;
 
     m_tilesManagers.insert(observer, tm);
 }
diff --git a/core/page.h b/core/page.h
index 3ffa3132b..69d04931f 100644
--- a/core/page.h
+++ b/core/page.h
@@ -1,414 +1,414 @@
 /***************************************************************************
  *   Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>                  *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #ifndef _OKULAR_PAGE_H_
 #define _OKULAR_PAGE_H_
 
 #include <QtCore/QLinkedList>
 
 #include "okularcore_export.h"
 #include "area.h"
 #include "global.h"
 #include "textpage.h"
 
 class QPixmap;
 
 class PagePainter;
 
 namespace Okular {
 
 class Annotation;
 class Document;
 class DocumentObserver;
 class DocumentPrivate;
 class FormField;
 class PagePrivate;
 class PageTransition;
 class SourceReference;
 class TextSelection;
 class Tile;
 
 /**
  * @short Collector for all the data belonging to a page.
  *
  * The Page class contains pixmaps (referenced using observers id as key),
  * a search page (a class used internally for retrieving text), rect classes
  * (that describe links or other active areas in the current page) and more.
  *
  * All coordinates are normalized to the page, so {x,y} are valid in [0,1]
  * range as long as NormalizedRect components.
  *
  * Note: The class takes ownership of all objects.
  */
 class OKULARCORE_EXPORT Page
 {
     public:
         /**
          * An action to be executed when particular events happen.
          */
         enum PageAction
         {
             Opening,       ///< An action to be executed when the page is "opened".
             Closing        ///< An action to be executed when the page is "closed".
         };
 
         /**
          * Creates a new page.
          *
          * @param number The number of the page in the document.
          * @param width The width of the page.
          * @param height The height of the page.
          * @param orientation The orientation of the page
          */
         Page( uint number, double width, double height, Rotation orientation );
 
         /**
          * Destroys the page.
          */
         ~Page();
 
         /**
          * Returns the number of the page in the document.
          */
         int number() const;
 
         /**
          * Returns the orientation of the page as defined by the document.
          */
         Rotation orientation() const;
 
         /**
          * Returns the rotation of the page as defined by the user.
          */
         Rotation rotation() const;
 
         /**
          * Returns the total orientation which is the original orientation plus
          * the user defined rotation.
          */
         Rotation totalOrientation() const;
 
         /**
          * Returns the width of the page.
          */
         double width() const;
 
         /**
          * Returns the height of the page.
          */
         double height() const;
 
         /**
          * Returns the ration (height / width) of the page.
          */
         double ratio() const;
 
         /**
          * Returns the bounding box of the page content in normalized [0,1] coordinates,
          * in terms of the upright orientation (Rotation0).
          * If it has not been computed yet, returns the full page (i.e., (0, 0, 1, 1)).
          * Note that the bounding box may be null if the page is blank.
          *
          * @since 0.7 (KDE 4.1)
          */
         NormalizedRect boundingBox() const;
 
         /**
          * Returns whether the bounding box of the page has been computed.
          * Note that even if the bounding box is computed, it may be null if the page is blank.
          *
          * @since 0.7 (KDE 4.1)
          */
         bool isBoundingBoxKnown() const;
 
         /**
          * Sets the bounding box of the page content in normalized [0,1] coordinates,
          * in terms of the upright orientation (Rotation0).
          * (This does not inform the document's observers, call Document::SetPageBoundingBox
          * instead if you want that.)
          *
          * @since 0.7 (KDE 4.1)
          */
         void setBoundingBox( const NormalizedRect& bbox );
 
         /**
          * Returns whether the page of size @p width x @p height has a @p pixmap 
          * in the region given by @p rect for the given @p observer
          */
         bool hasPixmap( DocumentObserver *observer, int width = -1, int height = -1, const NormalizedRect &rect = NormalizedRect() ) const;
 
         /**
          * Returns whether the page provides a text page (@ref TextPage).
          */
         bool hasTextPage() const;
 
         /**
          * Returns whether the page has an object rect which includes the point (@p x, @p y)
          * at scale (@p xScale, @p yScale).
          */
         bool hasObjectRect( double x, double y, double xScale, double yScale ) const;
 
         /**
          * Returns whether the page provides highlighting for the observer with the
          * given @p id.
          */
         bool hasHighlights( int id = -1 ) const;
 
         /**
          * Returns whether the page provides a transition effect.
          */
         bool hasTransition() const;
 
         /**
          * Returns whether the page provides annotations.
          */
         bool hasAnnotations() const;
 
         /**
          * Returns the bounding rect of the text which matches the following criteria
          * or 0 if the search is not successful.
          *
          * @param id An unique id for this search.
          * @param text The search text.
          * @param direction The direction of the search (@ref SearchDirection)
          * @param caseSensitivity If Qt::CaseSensitive, the search is case sensitive; otherwise
          *                        the search is case insensitive.
          * @param lastRect If 0 (default) the search starts at the beginning of the page, otherwise
          *                 right/below the coordinates of the given rect.
          */
         RegularAreaRect* findText( int id, const QString & text, SearchDirection direction,
                                    Qt::CaseSensitivity caseSensitivity, const RegularAreaRect * lastRect=0) const;
 
         /**
          * Returns the page text (or part of it).
          * @see TextPage::text()
          */
         QString text( const RegularAreaRect * rect = 0 ) const;
 
         /**
          * Returns the page text (or part of it).
          * @see TextPage::text()
          * @since 0.10 (KDE 4.4)
          */
         QString text( const RegularAreaRect * rect, TextPage::TextAreaInclusionBehaviour b ) const;
 
         /**
          * Returns the page text (or part of it) including the bounding
          * rectangles. Note that ownership of the contents of the returned
          * list belongs to the caller.
          * @see TextPage::words()
          * @since 0.14 (KDE 4.8)
          */
         TextEntity::List words( const RegularAreaRect * rect, TextPage::TextAreaInclusionBehaviour b ) const;
         
         /**
          * Returns the area and text of the word at the given point
          * Note that ownership of the returned area belongs to the caller.
          * @see TextPage::wordAt()
          * @since 0.15 (KDE 4.9)
          */
         RegularAreaRect * wordAt( const NormalizedPoint &p, QString *word = 0 ) const;
 
         /**
          * Returns the rectangular area of the given @p selection.
          */
         RegularAreaRect * textArea( TextSelection *selection ) const;
 
         /**
          * Returns the object rect of the given @p type which is at point (@p x, @p y) at scale (@p xScale, @p yScale).
          */
         const ObjectRect * objectRect( ObjectRect::ObjectType type, double x, double y, double xScale, double yScale ) const;
 
         /**
          * Returns all object rects of the given @p type which are at point (@p x, @p y) at scale (@p xScale, @p yScale).
          * @since 0.16 (KDE 4.10)
          */
         QLinkedList< const ObjectRect * > objectRects( ObjectRect::ObjectType type, double x, double y, double xScale, double yScale ) const;
 
         /**
          * Returns the object rect of the given @p type which is nearest to the point (@p x, @p y) at scale (@p xScale, @p yScale).
          *
          * @since 0.8.2 (KDE 4.2.2)
          */
         const ObjectRect * nearestObjectRect( ObjectRect::ObjectType type, double x, double y, double xScale, double yScale, double * distance ) const;
 
         /**
          * Returns the transition effect of the page or 0 if no transition
          * effect is set (see hasTransition()).
          */
         const PageTransition * transition() const;
 
         /**
          * Returns the list of annotations of the page.
          */
         QLinkedList< Annotation* > annotations() const;
 
         /**
          * Returns the @ref Action object which is associated with the given page @p action
          * or 0 if no page action is set.
          */
         const Action * pageAction( PageAction action ) const;
 
         /**
          * Returns the list of FormField of the page.
          */
         QLinkedList< FormField * > formFields() const;
 
         /**
          * Sets the region described by @p rect with @p pixmap for the
          * given @p observer.
          * If @p rect is not set (default) the @p pixmap is set to the entire
          * page.
          */
         void setPixmap( DocumentObserver *observer, QPixmap *pixmap, const NormalizedRect &rect = NormalizedRect() );
 
         /**
          * Sets the @p text page.
          */
         void setTextPage( TextPage * text );
 
         /**
          * Sets the list of object @p rects of the page.
          */
         void setObjectRects( const QLinkedList< ObjectRect * > & rects );
 
         /**
          * Sets the list of source reference objects @p rects.
          */
         void setSourceReferences( const QLinkedList< SourceRefObjectRect * > & rects );
 
         /**
          * Sets the duration of the page to @p seconds when displayed in presentation mode.
          *
          * Setting a negative number disables the duration.
          */
         void setDuration( double seconds );
 
         /**
          * Returns the duration in seconds of the page when displayed in presentation mode.
          *
          * A negative number means that no time is set.
          */
         double duration() const;
 
         /**
          * Sets the labels for the page to @p label .
          */
         void setLabel( const QString& label );
 
         /**
          * Returns the label of the page, or a null string if not set.
          */
         QString label() const;
 
         /**
          * Returns the current text selection.
          */
         const RegularAreaRect * textSelection() const;
 
         /**
          * Returns the color of the current text selection, or an invalid color
          * if no text selection has been set.
          */
         QColor textSelectionColor() const;
 
         /**
          * Adds a new @p annotation to the page.
          */
         void addAnnotation( Annotation * annotation );
 
         /**
          * Removes the @p annotation from the page.
          */
         bool removeAnnotation( Annotation * annotation );
 
         /**
          * Sets the page @p transition effect.
          */
         void setTransition( PageTransition * transition );
 
         /**
          * Sets the @p link object for the given page @p action.
          */
         void setPageAction( PageAction action, Action * link );
 
         /**
          * Sets @p fields as list of FormField of the page.
          */
         void setFormFields( const QLinkedList< FormField * >& fields );
 
         /**
          * Deletes the pixmap for the given @p observer
          */
         void deletePixmap( DocumentObserver *observer );
 
         /**
          * Deletes all pixmaps of the page.
          */
         void deletePixmaps();
 
         /**
          * Deletes all object rects of the page.
          */
         void deleteRects();
 
         /**
          * Deletes all source reference objects of the page.
          */
         void deleteSourceReferences();
 
         /**
          * Deletes all annotations of the page.
          */
         void deleteAnnotations();
 
         /**
          * Returns whether pixmaps for the tiled observer are handled by a
          * tile manager.
          *
          * @since 0.19 (KDE 4.13)
          */
         bool hasTilesManager( const DocumentObserver *observer ) const;
 
         /**
          * Returns a list of all tiles intersecting with @p rect.
          *
          * The list contains only tiles with a pixmap
          *
          * @since 0.19 (KDE 4.13)
          */
         QList<Tile> tilesAt( const DocumentObserver *observer, const NormalizedRect &rect ) const;
 
     private:
         PagePrivate* const d;
         /// @cond PRIVATE
         friend class PagePrivate;
         friend class Document;
         friend class DocumentPrivate;
         friend class PixmapRequestPrivate;
 
         /**
          * To improve performance PagePainter accesses the following
          * member variables directly.
          */
         friend class ::PagePainter;
         /// @endcond
 
-        const QPixmap * _o_nearestPixmap( DocumentObserver *, int, int, qreal ) const;
+        const QPixmap * _o_nearestPixmap( DocumentObserver *, int, int ) const;
 
         QLinkedList< ObjectRect* > m_rects;
         QLinkedList< HighlightAreaRect* > m_highlights;
         QLinkedList< Annotation* > m_annotations;
 
         Q_DISABLE_COPY( Page )
 };
 
 }
 
 #endif
diff --git a/core/tilesmanager.cpp b/core/tilesmanager.cpp
index 46b1d38bc..7600d1a2a 100644
--- a/core/tilesmanager.cpp
+++ b/core/tilesmanager.cpp
@@ -1,720 +1,709 @@
 /***************************************************************************
  *   Copyright (C) 2012 by Mailson Menezes <mailson@gmail.com>             *
  *   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.                                   *
  ***************************************************************************/
 
 #include "tilesmanager_p.h"
 
 #include <QPixmap>
 #include <QtCore/qmath.h>
 #include <QList>
 #include <QPainter>
 
 #include "tile.h"
 
 #define TILES_MAXSIZE 2000000
 
 using namespace Okular;
 
 static bool rankedTilesLessThan( TileNode *t1, TileNode *t2 )
 {
     // Order tiles by its dirty state and then by distance from the viewport.
     if ( t1->dirty == t2->dirty )
         return t1->distance < t2->distance;
 
     return !t1->dirty;
 }
 
 class TilesManager::Private
 {
     public:
         Private();
 
         bool hasPixmap( const NormalizedRect &rect, const TileNode &tile ) const;
         void tilesAt( const NormalizedRect &rect, TileNode &tile, QList<Tile> &result, TileLeaf tileLeaf );
         void setPixmap( const QPixmap *pixmap, const NormalizedRect &rect, TileNode &tile );
 
         /**
          * Mark @p tile and all its children as dirty
          */
         static void markDirty( TileNode &tile );
 
         /**
          * Deletes all tiles, recursively
          */
         void deleteTiles( const TileNode &tile );
 
         void markParentDirty( const TileNode &tile );
         void rankTiles( TileNode &tile, QList<TileNode*> &rankedTiles, const NormalizedRect &visibleRect, int visiblePageNumber );
         /**
          * Since the tile can be large enough to occupy a significant amount of
          * space, they may be split in more tiles. This operation is performed
          * when the tiles of a certain region is requested and they are bigger
          * than an arbitrary value. Only tiles intersecting the desired region
          * are split. There's no need to do this for the entire page.
          */
         void split( TileNode &tile, const NormalizedRect &rect );
 
         /**
          * Checks whether the tile's size is bigger than an arbitrary value and
          * performs the split operation returning true.
          * Otherwise it just returns false, without performing any operation.
          */
         bool splitBigTiles( TileNode &tile, const NormalizedRect &rect );
 
         // The page is split in a 4x4 grid of tiles
         TileNode tiles[16];
         int width;
         int height;
-        qreal dpr;
         int pageNumber;
         qulonglong totalPixels;
         Rotation rotation;
         NormalizedRect visibleRect;
         NormalizedRect requestRect;
         int requestWidth;
         int requestHeight;
 };
 
 TilesManager::Private::Private()
     : width( 0 )
     , height( 0 )
-    , dpr ( 1.0 )
     , pageNumber( 0 )
     , totalPixels( 0 )
     , rotation( Rotation0 )
     , requestRect( NormalizedRect() )
     , requestWidth( 0 )
     , requestHeight( 0 )
 {
 }
 
-TilesManager::TilesManager( int pageNumber, int width, int height, qreal dpr, Rotation rotation )
+TilesManager::TilesManager( int pageNumber, int width, int height, Rotation rotation )
     : d( new Private )
 {
     d->pageNumber = pageNumber;
     d->width = width;
     d->height = height;
-    d->dpr = dpr;
     d->rotation = rotation;
 
     // The page is split in a 4x4 grid of tiles
     const double dim = 0.25;
     for ( int i = 0; i < 16; ++i )
     {
         int x = i % 4;
         int y = i / 4;
         d->tiles[ i ].rect = NormalizedRect( x*dim, y*dim, x*dim+dim, y*dim+dim );
     }
 }
 
 TilesManager::~TilesManager()
 {
     for ( int i = 0; i < 16; ++i )
         d->deleteTiles( d->tiles[ i ] );
 
     delete d;
 }
 
 void TilesManager::Private::deleteTiles( const TileNode &tile )
 {
     if ( tile.pixmap )
     {
         totalPixels -= tile.pixmap->width()*tile.pixmap->height();
         delete tile.pixmap;
     }
 
     if ( tile.nTiles > 0 )
     {
         for ( int i = 0; i < tile.nTiles; ++i )
             deleteTiles( tile.tiles[ i ] );
 
         delete [] tile.tiles;
     }
 }
 
 void TilesManager::setSize( int width, int height )
 {
     if ( width == d->width && height == d->height )
         return;
 
     d->width = width;
     d->height = height;
 
     markDirty();
 }
 
 int TilesManager::width() const
 {
     return d->width;
 }
 
 int TilesManager::height() const
 {
     return d->height;
 }
 
-qreal TilesManager::devicePixelRatio() const
-{
-    return d->dpr;
-}
-
 void TilesManager::setRotation( Rotation rotation )
 {
     if ( rotation == d->rotation )
         return;
 
     d->rotation = rotation;
 }
 
 Rotation TilesManager::rotation() const
 {
     return d->rotation;
 }
 
 void TilesManager::markDirty()
 {
     for ( int i = 0; i < 16; ++i )
     {
         TilesManager::Private::markDirty( d->tiles[ i ] );
     }
 }
 
 void TilesManager::Private::markDirty( TileNode &tile )
 {
     tile.dirty = true;
 
     for ( int i = 0; i < tile.nTiles; ++i )
     {
         markDirty( tile.tiles[ i ] );
     }
 }
 
 void TilesManager::setPixmap( const QPixmap *pixmap, const NormalizedRect &rect )
 {
     NormalizedRect rotatedRect = TilesManager::fromRotatedRect( rect, d->rotation );
     if ( !d->requestRect.isNull() )
     {
         if ( !(d->requestRect == rect) )
             return;
 
         // Check whether the pixmap has the same absolute size of the expected
         // request.
         // If the document is rotated, rotate requestRect back to the original
         // rotation before comparing to pixmap's size. This is to avoid
         // conversion issues. The pixmap request was made using an unrotated
         // rect.
-        QSize pixmapSize = pixmap->size();// / pixmap->devicePixelRatioF();
+        QSize pixmapSize = pixmap->size();
         int w = width();
         int h = height();
         if ( d->rotation % 2 )
         {
             qSwap(w, h);
             pixmapSize.transpose();
         }
 
         if ( rotatedRect.geometry( w, h ).size() != pixmapSize )
             return;
 
         d->requestRect = NormalizedRect();
     }
 
     for ( int i = 0; i < 16; ++i )
     {
         d->setPixmap( pixmap, rotatedRect, d->tiles[ i ] );
     }
 }
 
 void TilesManager::Private::setPixmap( const QPixmap *pixmap, const NormalizedRect &rect, TileNode &tile )
 {
     QRect pixmapRect = TilesManager::toRotatedRect( rect, rotation ).geometry( width, height );
 
     // Exclude tiles outside the viewport
     if ( !tile.rect.intersects( rect ) )
         return;
 
     // if the tile is not entirely within the viewport (the tile intersects an
     // edged of the viewport), attempt to set the pixmap in the children tiles
     if ( !((tile.rect & rect) == tile.rect) )
     {
         // paint children tiles
         if ( tile.nTiles > 0 )
         {
             for ( int i = 0; i < tile.nTiles; ++i )
                 setPixmap( pixmap, rect, tile.tiles[ i ] );
 
             delete tile.pixmap;
             tile.pixmap = 0;
         }
 
         return;
     }
 
     // the tile lies entirely within the viewport
     if ( tile.nTiles == 0 )
     {
         tile.dirty = false;
 
         // check whether the tile size is big and split it if necessary
         if ( !splitBigTiles( tile, rect ) )
         {
             if ( tile.pixmap )
             {
                 totalPixels -= tile.pixmap->width()*tile.pixmap->height();
                 delete tile.pixmap;
             }
             NormalizedRect rotatedRect = TilesManager::toRotatedRect( tile.rect, rotation );
-            tile.pixmap = new QPixmap( pixmap->copy( rotatedRect.geometry( width/* * pixmap->devicePixelRatioF()*/, height /** pixmap->devicePixelRatioF()*/ ).translated( -pixmapRect.topLeft() ) ) );
-            //tile.pixmap->setDevicePixelRatio(pixmap->devicePixelRatioF());
+            tile.pixmap = new QPixmap( pixmap->copy( rotatedRect.geometry( width, height ).translated( -pixmapRect.topLeft() ) ) );
             tile.rotation = rotation;
             totalPixels += tile.pixmap->width()*tile.pixmap->height();
         }
         else
         {
             if ( tile.pixmap )
             {
                 totalPixels -= tile.pixmap->width()*tile.pixmap->height();
                 delete tile.pixmap;
                 tile.pixmap = 0;
             }
 
             for ( int i = 0; i < tile.nTiles; ++i )
                 setPixmap( pixmap, rect, tile.tiles[ i ] );
         }
     }
     else
     {
         QRect tileRect = tile.rect.geometry( width, height );
         // sets the pixmap of the children tiles. if the tile's size is too
         // small, discards the children tiles and use the current one
         if ( tileRect.width()*tileRect.height() >= TILES_MAXSIZE )
         {
             tile.dirty = false;
             if ( tile.pixmap )
             {
                 totalPixels -= tile.pixmap->width()*tile.pixmap->height();
                 delete tile.pixmap;
                 tile.pixmap = 0;
             }
 
             for ( int i = 0; i < tile.nTiles; ++i )
                 setPixmap( pixmap, rect, tile.tiles[ i ] );
         }
         else
         {
             // remove children tiles
             for ( int i = 0; i < tile.nTiles; ++i )
             {
                 deleteTiles( tile.tiles[ i ] );
                 tile.tiles[ i ].pixmap = 0;
             }
 
             delete [] tile.tiles;
             tile.tiles = 0;
             tile.nTiles = 0;
 
             // paint tile
             if ( tile.pixmap )
             {
                 totalPixels -= tile.pixmap->width()*tile.pixmap->height();
                 delete tile.pixmap;
             }
             NormalizedRect rotatedRect = TilesManager::toRotatedRect( tile.rect, rotation );
-            tile.pixmap = new QPixmap( pixmap->copy( rotatedRect.geometry( width/* * pixmap->devicePixelRatioF()*/, height/* * pixmap->devicePixelRatioF()*/ ).translated( -pixmapRect.topLeft() ) ) );
-            //tile.pixmap->setDevicePixelRatio(pixmap->devicePixelRatioF());
+            tile.pixmap = new QPixmap( pixmap->copy( rotatedRect.geometry( width, height ).translated( -pixmapRect.topLeft() ) ) );
             tile.rotation = rotation;
             totalPixels += tile.pixmap->width()*tile.pixmap->height();
             tile.dirty = false;
         }
     }
 }
 
 bool TilesManager::hasPixmap( const NormalizedRect &rect )
 {
     NormalizedRect rotatedRect = fromRotatedRect( rect, d->rotation );
     for ( int i = 0; i < 16; ++i )
     {
         if ( !d->hasPixmap( rotatedRect, d->tiles[ i ] ) )
             return false;
     }
 
     return true;
 }
 
 bool TilesManager::Private::hasPixmap( const NormalizedRect &rect, const TileNode &tile ) const
 {
     if ( !tile.rect.intersects( rect ) )
         return true;
 
     if ( tile.nTiles == 0 )
         return tile.isValid();
 
     // all children tiles are clean. doesn't need to go deeper
     if ( !tile.dirty )
         return true;
 
     for ( int i = 0; i < tile.nTiles; ++i )
     {
         if ( !hasPixmap( rect, tile.tiles[ i ] ) )
             return false;
     }
 
     return true;
 }
 
 QList<Tile> TilesManager::tilesAt( const NormalizedRect &rect, TileLeaf tileLeaf )
 {
     QList<Tile> result;
 
     NormalizedRect rotatedRect = fromRotatedRect( rect, d->rotation );
     for ( int i = 0; i < 16; ++i )
     {
         d->tilesAt( rotatedRect, d->tiles[ i ], result, tileLeaf );
     }
 
     return result;
 }
 
 void TilesManager::Private::tilesAt( const NormalizedRect &rect, TileNode &tile, QList<Tile> &result, TileLeaf tileLeaf )
 {
     if ( !tile.rect.intersects( rect ) )
         return;
 
     // split big tiles before the requests are made, otherwise we would end up
     // requesting huge areas unnecessarily
     splitBigTiles( tile, rect );
 
     if ( ( tileLeaf == TerminalTile && tile.nTiles == 0 ) || ( tileLeaf == PixmapTile && tile.pixmap ) )
     {
         NormalizedRect rotatedRect;
         if ( rotation != Rotation0 )
             rotatedRect = TilesManager::toRotatedRect( tile.rect, rotation );
         else
             rotatedRect = tile.rect;
 
         if ( tile.pixmap && tileLeaf == PixmapTile && tile.rotation != rotation )
         {
             // Lazy tiles rotation
             int angleToRotate = (rotation - tile.rotation)*90;
             int xOffset = 0, yOffset = 0;
             int w = 0, h = 0;
             switch( angleToRotate )
             {
                 case 0:
                     xOffset = 0;
                     yOffset = 0;
                     w = tile.pixmap->width();
                     h = tile.pixmap->height();
                     break;
                 case 90:
                 case -270:
                     xOffset = 0;
                     yOffset = -tile.pixmap->height();
                     w = tile.pixmap->height();
                     h = tile.pixmap->width();
                     break;
                 case 180:
                 case -180:
                     xOffset = -tile.pixmap->width();
                     yOffset = -tile.pixmap->height();
                     w = tile.pixmap->width();
                     h = tile.pixmap->height();
                     break;
                 case 270:
                 case -90:
                     xOffset = -tile.pixmap->width();
                     yOffset = 0;
                     w = tile.pixmap->height();
                     h = tile.pixmap->width();
                     break;
             }
-            QPixmap *rotatedPixmap = new QPixmap( w * tile.pixmap->width(), h  * tile.pixmap->height() );
-            //rotatedPixmap->setDevicePixelRatio(tile.pixmap->devicePixelRatioF());
+            QPixmap *rotatedPixmap = new QPixmap( w, h );
             QPainter p( rotatedPixmap );
             p.rotate( angleToRotate );
             p.translate( xOffset, yOffset );
             p.drawPixmap( 0, 0, *tile.pixmap );
             p.end();
 
             delete tile.pixmap;
             tile.pixmap = rotatedPixmap;
             tile.rotation = rotation;
         }
         result.append( Tile( rotatedRect, tile.pixmap, tile.isValid() ) );
     }
     else
     {
         for ( int i = 0; i < tile.nTiles; ++i )
             tilesAt( rect, tile.tiles[ i ], result, tileLeaf );
     }
 }
 
 qulonglong TilesManager::totalMemory() const
 {
     return 4*d->totalPixels;
 }
 
 void TilesManager::cleanupPixmapMemory( qulonglong numberOfBytes, const NormalizedRect &visibleRect, int visiblePageNumber )
 {
     QList<TileNode*> rankedTiles;
     for ( int i = 0; i < 16; ++i )
     {
         d->rankTiles( d->tiles[ i ], rankedTiles, visibleRect, visiblePageNumber );
     }
     qSort( rankedTiles.begin(), rankedTiles.end(), rankedTilesLessThan );
 
     while ( numberOfBytes > 0 && !rankedTiles.isEmpty() )
     {
         TileNode *tile = rankedTiles.takeLast();
         if ( !tile->pixmap )
             continue;
 
         // do not evict visible pixmaps
         if ( tile->rect.intersects( visibleRect ) )
             continue;
 
         qulonglong pixels = tile->pixmap->width()*tile->pixmap->height();
         d->totalPixels -= pixels;
         if ( numberOfBytes < 4*pixels )
             numberOfBytes = 0;
         else
             numberOfBytes -= 4*pixels;
 
         delete tile->pixmap;
         tile->pixmap = 0;
 
         d->markParentDirty( *tile );
     }
 }
 
 void TilesManager::Private::markParentDirty( const TileNode &tile )
 {
     if ( !tile.parent )
         return;
 
     if ( !tile.parent->dirty )
     {
         tile.parent->dirty = true;
         markParentDirty( *tile.parent );
     }
 }
 
 void TilesManager::Private::rankTiles( TileNode &tile, QList<TileNode*> &rankedTiles, const NormalizedRect &visibleRect, int visiblePageNumber )
 {
     // If the page is visible, visibleRect is not null.
     // Otherwise we use the number of one of the visible pages to calculate the
     // distance.
     // Note that the current page may be visible and yet its pageNumber is
     // different from visiblePageNumber. Since we only use this value on hidden
     // pages, any visible page number will fit.
     if ( visibleRect.isNull() && visiblePageNumber < 0 )
         return;
 
     if ( tile.pixmap )
     {
         // Update distance
         if ( !visibleRect.isNull() )
         {
             NormalizedPoint viewportCenter = visibleRect.center();
             NormalizedPoint tileCenter = tile.rect.center();
             // Manhattan distance. It's a good and fast approximation.
             tile.distance = qAbs(viewportCenter.x - tileCenter.x) + qAbs(viewportCenter.y - tileCenter.y);
         }
         else
         {
             // For non visible pages only the vertical distance is used
             if ( pageNumber < visiblePageNumber )
                 tile.distance = 1 - tile.rect.bottom;
             else
                 tile.distance = tile.rect.top;
         }
         rankedTiles.append( &tile );
     }
     else
     {
         for ( int i = 0; i < tile.nTiles; ++i )
         {
             rankTiles( tile.tiles[ i ], rankedTiles, visibleRect, visiblePageNumber );
         }
     }
 }
 
 bool TilesManager::isRequesting( const NormalizedRect &rect, int pageWidth, int pageHeight ) const
 {
     return rect == d->requestRect && pageWidth == d->requestWidth && pageHeight == d->requestHeight;
 }
 
 void TilesManager::setRequest( const NormalizedRect &rect, int pageWidth, int pageHeight )
 {
     d->requestRect = rect;
     d->requestWidth = pageWidth;
     d->requestHeight = pageHeight;
 }
 
 bool TilesManager::Private::splitBigTiles( TileNode &tile, const NormalizedRect &rect )
 {
     QRect tileRect = tile.rect.geometry( width, height );
     if ( tileRect.width()*tileRect.height() < TILES_MAXSIZE )
         return false;
 
     split( tile, rect );
     return true;
 }
 
 void TilesManager::Private::split( TileNode &tile, const NormalizedRect &rect )
 {
     if ( tile.nTiles != 0 )
         return;
 
     if ( rect.isNull() || !tile.rect.intersects( rect ) )
         return;
 
     tile.nTiles = 4;
     tile.tiles = new TileNode[4];
     double hCenter = (tile.rect.left + tile.rect.right)/2;
     double vCenter = (tile.rect.top + tile.rect.bottom)/2;
 
     tile.tiles[0].rect = NormalizedRect( tile.rect.left, tile.rect.top, hCenter, vCenter );
     tile.tiles[1].rect = NormalizedRect( hCenter, tile.rect.top, tile.rect.right, vCenter );
     tile.tiles[2].rect = NormalizedRect( tile.rect.left, vCenter, hCenter, tile.rect.bottom );
     tile.tiles[3].rect = NormalizedRect( hCenter, vCenter, tile.rect.right, tile.rect.bottom );
 
     for ( int i = 0; i < tile.nTiles; ++i )
     {
         tile.tiles[ i ].parent = &tile;
         splitBigTiles( tile.tiles[ i ], rect );
     }
 }
 
 NormalizedRect TilesManager::fromRotatedRect( const NormalizedRect &rect, Rotation rotation )
 {
     if ( rotation == Rotation0 )
         return rect;
 
     NormalizedRect newRect;
     switch ( rotation )
     {
         case Rotation90:
             newRect = NormalizedRect( rect.top, 1 - rect.right, rect.bottom, 1 - rect.left );
             break;
         case Rotation180:
             newRect = NormalizedRect( 1 - rect.right, 1 - rect.bottom, 1 - rect.left, 1 - rect.top );
             break;
         case Rotation270:
             newRect = NormalizedRect( 1 - rect.bottom, rect.left, 1 - rect.top, rect.right );
             break;
         default:
             newRect = rect;
             break;
     }
 
     return newRect;
 }
 
 NormalizedRect TilesManager::toRotatedRect( const NormalizedRect &rect, Rotation rotation )
 {
     if ( rotation == Rotation0 )
         return rect;
 
     NormalizedRect newRect;
     switch ( rotation )
     {
         case Rotation90:
             newRect = NormalizedRect( 1 - rect.bottom, rect.left, 1 - rect.top, rect.right );
             break;
         case Rotation180:
             newRect = NormalizedRect( 1 - rect.right, 1 - rect.bottom, 1 - rect.left, 1 - rect.top );
             break;
         case Rotation270:
             newRect = NormalizedRect( rect.top, 1 - rect.right, rect.bottom, 1 - rect.left );
             break;
         default:
             newRect = rect;
             break;
     }
 
     return newRect;
 }
 
 TileNode::TileNode()
     : pixmap( 0 )
     , rotation( Rotation0 )
     , dirty ( true )
     , distance( -1 )
     , tiles( 0 )
     , nTiles( 0 )
     , parent( 0 )
 {
 }
 
 bool TileNode::isValid() const
 {
     return pixmap && !dirty;
 }
 
 class Tile::Private
 {
     public:
         Private();
 
         NormalizedRect rect;
         QPixmap *pixmap;
         bool isValid;
 };
 
 Tile::Private::Private()
     : pixmap( 0 )
     , isValid( false )
 {
 }
 
 Tile::Tile( const NormalizedRect &rect, QPixmap *pixmap, bool isValid )
     : d( new Tile::Private )
 {
     d->rect = rect;
     d->pixmap = pixmap;
     d->isValid = isValid;
 }
 
 Tile::Tile( const Tile &t )
     : d( new Tile::Private )
 {
     d->rect = t.d->rect;
     d->pixmap = t.d->pixmap;
     d->isValid = t.d->isValid;
 }
 
 Tile& Tile::operator=( const Tile &other )
 {
     if ( this == &other )
         return *this;
 
     d->rect = other.d->rect;
     d->pixmap = other.d->pixmap;
     d->isValid = other.d->isValid;
 
     return *this;
 }
 
 Tile::~Tile()
 {
     delete d;
 }
 
 NormalizedRect Tile::rect() const
 {
     return d->rect;
 }
 
 QPixmap * Tile::pixmap() const
 {
     return d->pixmap;
 }
 
 bool Tile::isValid() const
 {
     return d->isValid;
 }
diff --git a/core/tilesmanager_p.h b/core/tilesmanager_p.h
index 46b0621b0..44aa78ae9 100644
--- a/core/tilesmanager_p.h
+++ b/core/tilesmanager_p.h
@@ -1,212 +1,207 @@
 /***************************************************************************
  *   Copyright (C) 2012 by Mailson Menezes <mailson@gmail.com>             *
  *   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.                                   *
  ***************************************************************************/
 
 #ifndef _OKULAR_TILES_MANAGER_P_H_
 #define _OKULAR_TILES_MANAGER_P_H_
 
 #include "okularcore_export.h"
 #include "area.h"
 
 class QPixmap;
 
 namespace Okular {
 
 class Tile;
 
 /**
  * Node in the quadtree structure used by the tiles manager to store tiles.
  *
  * Except for the first level, the tiles manager stores tiles in a quadtree
  * structure.
  * Each node stores the pixmap of a tile and its location on the page.
  * There's a limit on the size of the pixmaps (TILES_MAXSIZE, defined in
  * tilesmanager.cpp), and tiles that are bigger than that value are split into
  * four children tiles, which are stored as children of the original tile.
  * If children tiles are still too big, they are recursively split again.
  * If the zoom level changes and a big tile goes below the limit, it is merged
  * back into a leaf tile.
  */
 class TileNode
 {
     public:
         TileNode();
 
         bool isValid() const;
 
         /**
          * Location on the page in normalized coords
          */
         NormalizedRect rect;
 
         /**
          * Associated pixmap or NULL if not present
          *
          * For each node, it is guaranteed that there's no more than one pixmap
          * along the path from the root to the node itself.
          * In fact, it is very frequent that a leaf node has no pixmap and one
          * of its ancestors has. Such a situation shows, for example, when the
          * parent tile still has a dirty tile from a previous lower zoom level.
          */
         QPixmap *pixmap;
 
         /**
          * Rotation of this individual tile.
          *
          * A rotation to the page does not immediately rotates the pixmaps in
          * cache. This operation happens when pixmaps are going to be used.
          */
         Rotation rotation;
 
         /**
          * Whether the tile needs to be repainted (after a zoom or rotation)
          * If a tile doesn't have a pixmap but all its children are updated
          * (dirty = false), the parent tile is also considered updated.
          */
         bool dirty;
 
         /**
          * Distance between the tile and the viewport.
          * This is used by the evicting algorithm.
          */
         double distance;
 
         /**
          * Children tiles
          * When a tile is split into multiple tiles, they're added as children.
          * nTiles can be either 0 (in leaf tiles) or 4 (in split tiles).
          */
         TileNode *tiles;
         int nTiles;
         TileNode *parent;
 };
 
 /**
  * @short Tiles management
  *
  * This class has direct access to all tiles and handles how they should be
  * stored, deleted and retrieved. Each tiles manager only handles one page.
  *
  * The tiles manager is a tree of tiles. At first the page is divided in a 4x4
  * grid of 16 tiles. Then each of these tiles can be recursively split in 4
  * subtiles so that we keep the size of each pixmap inside a safe interval.
  */
 class TilesManager
 {
     public:
         enum TileLeaf
         {
             TerminalTile,     ///< Return tiles without children
             PixmapTile        ///< Return only tiles with pixmap
         };
 
-        TilesManager( int pageNumber, int width, int height, qreal dpr, Rotation rotation = Rotation0 );
+        TilesManager( int pageNumber, int width, int height, Rotation rotation = Rotation0 );
         ~TilesManager();
 
         /**
          * Sets the pixmap of the tiles covered by @p rect (which represents
          * the location of @p pixmap on the page).
          * @p pixmap may cover an area which contains multiple tiles. So each
          * tile we get a cropped part of the @p pixmap.
          *
          * Also it checks the dimensions of the given parameters against the
          * current request as to avoid setting pixmaps of late requests.
          */
         void setPixmap( const QPixmap *pixmap, const NormalizedRect &rect );
 
         /**
          * Checks whether all tiles intersecting with @p rect are available.
          * Returns false if at least one tile needs to be repainted (the tile
          * is dirty).
          */
         bool hasPixmap( const NormalizedRect &rect );
 
         /**
          * Returns a list of all tiles intersecting with @p rect.
          *
          * As to avoid requests of big areas, each traversed tile is checked
          * for its size and split if necessary.
          *
          * @param tileLeaf Indicate the type of tile to return
          */
         QList<Tile> tilesAt( const NormalizedRect &rect, TileLeaf tileLeaf );
 
         /**
          * The total memory consumed by the tiles manager
          */
         qulonglong totalMemory() const;
 
         /**
          * Removes at least @p numberOfBytes bytes worth of tiles (least ranked
          * tiles are removed first).
          * Set @p visibleRect to the visible region of the page. Set a
          * @p visiblePageNumber if the current page is not visible.
          * Visible tiles are not discarded.
          */
         void cleanupPixmapMemory( qulonglong numberOfBytes, const NormalizedRect &visibleRect, int visiblePageNumber );
 
         /**
          * Checks whether a given region has already been requested
          */
         bool isRequesting( const NormalizedRect &rect, int pageWidth, int pageHeight ) const;
 
         /**
          * Sets a region to be requested so the tiles manager knows which
          * pixmaps to expect and discard those not useful anymore (late pixmaps)
          */
         void setRequest( const NormalizedRect &rect, int pageWidth, int pageHeight );
 
         /**
          * Inform the new size of the page and mark all tiles to repaint
          */
         void setSize( int width, int height );
 
         /**
          * Gets the width of the page in tiles manager
          */
         int width() const;
 
         /**
          * Gets the height of the page in tiles manager
          */
         int height() const;
 
-        /**
-         * Gets the device pixel ratio of the page in tiles manager
-         */
-        qreal devicePixelRatio() const;
-
         /**
          * Inform the new rotation of the page
          */
         void setRotation( Rotation rotation );
         Rotation rotation() const;
 
         /**
          * Mark all tiles as dirty
          */
         void markDirty();
 
         /**
          * Returns a rotated NormalizedRect given a @p rotation
          */
         static NormalizedRect toRotatedRect( const NormalizedRect &rect, Rotation rotation );
 
         /**
          * Returns a non rotated version of @p rect, which is rotated by @p rotation
          */
         static NormalizedRect fromRotatedRect( const NormalizedRect &rect, Rotation rotation );
 
     private:
         class Private;
         Private * const d;
         friend class Private;
 };
 
 }
 
 #endif // _OKULAR_TILES_MANAGER_P_H_
diff --git a/generators/kimgio/tests/kimgiotest.cpp b/generators/kimgio/tests/kimgiotest.cpp
index 5c8c987ff..8ed9e1602 100644
--- a/generators/kimgio/tests/kimgiotest.cpp
+++ b/generators/kimgio/tests/kimgiotest.cpp
@@ -1,120 +1,120 @@
 /***************************************************************************
  *   Copyright (C) 2013 by Fabio D'Urso <fabiodurso@hotmail.it>            *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 
 #include "../generator_kimgio.h"
 #include "../../settings_core.h"
 
 #include <core/observer.h>
 #include <core/page.h>
 #include <ui/pagepainter.h>
 
 #include <QtTest>
 
 #include <QImage>
 #include <QPainter>
 #include <QImageReader>
 #include <QTemporaryFile>
 #include <KPluginLoader>
 
 class KIMGIOTest
 : public QObject
 {
 	Q_OBJECT
 
 	private slots:
 		void initTestCase();
 		void testExifOrientation_data();
 		void testExifOrientation();
 };
 
 void KIMGIOTest::initTestCase()
 {
 	// Make sure we find the okularGenerator_kimgio that we build just now and not the system one
     QFileInfo lib( QStringLiteral(GENERATOR_PATH) );
 	QVERIFY2( lib.exists(), GENERATOR_PATH );
 	QStringList libPaths = QCoreApplication::libraryPaths();
 	libPaths.prepend( lib.absolutePath() );
 	QCoreApplication::setLibraryPaths( libPaths );
     QVERIFY( !KPluginLoader::findPlugin( QStringLiteral("okularGenerator_kimgio") ).isEmpty() );
 	// make sure we didn't break the search path for image formats:
 	auto availableFormats = QImageReader::supportedImageFormats();
 	QVERIFY2(availableFormats.contains( "jpeg" ), availableFormats.join( ", " ).data() );
 }
 
 
 // The following images have different Exif orientation tags, but they all
 // are a 3x2 rectangle whose top-left pixel is black, and whose other pixels are
 // white. Note that, due to JPEG lossy compression, some pixels are not pure
 // white. In testExifOrientation, we only check the top-left and bottom-right
 // corners.
 void KIMGIOTest::testExifOrientation_data()
 {
 	QTest::addColumn<QString>( "imgPath" );
 
 	// No Exif metadata at all
 	QTest::newRow( "No Exif metadata" ) << KDESRCDIR "tests/data/testExifOrientation-noexif.jpg";
 
 	// No Exif orientation information
 	QTest::newRow( "Unspecified" ) << KDESRCDIR "tests/data/testExifOrientation-unspecified.jpg";
 
 	// Valid Orientation values
 	QTest::newRow( "Horizontal (normal)" ) << KDESRCDIR "tests/data/testExifOrientation-0.jpg";
 	QTest::newRow( "Mirror horizontal" ) << KDESRCDIR "tests/data/testExifOrientation-0mirror.jpg";
 	QTest::newRow( "Rotate 90 CW" ) << KDESRCDIR "tests/data/testExifOrientation-90.jpg";
 	QTest::newRow( "Mirror horizontal and rotate 90 CW" ) << KDESRCDIR "tests/data/testExifOrientation-90mirror.jpg";
 	QTest::newRow( "Rotate 180" ) << KDESRCDIR "tests/data/testExifOrientation-180.jpg";
 	QTest::newRow( "Mirror vertical" ) << KDESRCDIR "tests/data/testExifOrientation-180mirror.jpg";
 	QTest::newRow( "Rotate 270 CW" ) << KDESRCDIR "tests/data/testExifOrientation-270.jpg";
 	QTest::newRow( "Mirror horizontal and rotate 270 CW" ) << KDESRCDIR "tests/data/testExifOrientation-270mirror.jpg";
 }
 
 void KIMGIOTest::testExifOrientation()
 {
 	QFETCH( QString, imgPath );
 	QMimeDatabase db;
 
     Okular::SettingsCore::instance( QStringLiteral("kimgiotest") );
 	Okular::Document *m_document = new Okular::Document( 0 );
 	const QMimeType mime = db.mimeTypeForFile( imgPath );
 
 	Okular::DocumentObserver *dummyDocumentObserver = new Okular::DocumentObserver();
 	m_document->addObserver( dummyDocumentObserver );
 
 	// Load image
 	QCOMPARE((int)m_document->openDocument( imgPath, QUrl(), mime ), (int)Okular::Document::OpenSuccess);
 	m_document->setRotation( 0 ); // Test the default rotation
 	QCOMPARE( m_document->pages(), 1u );
 
 	// Check size
 	QCOMPARE( m_document->page(0)->width(), double(3) );
 	QCOMPARE( m_document->page(0)->height(), double(2) );
 
 	// Generate pixmap
-	Okular::PixmapRequest *req = new Okular::PixmapRequest( dummyDocumentObserver, 0, 3, 2, 1.0,
+	Okular::PixmapRequest *req = new Okular::PixmapRequest( dummyDocumentObserver, 0, 3, 2,
 		1, Okular::PixmapRequest::NoFeature );
 	m_document->requestPixmaps( QLinkedList<Okular::PixmapRequest*>() << req );
 	QVERIFY( m_document->page(0)->hasPixmap( dummyDocumentObserver, 3, 2 ) );
 
 	// Obtain image
 	QImage img( 3, 2, QImage::Format_ARGB32_Premultiplied );
 	QPainter p( &img );
 	PagePainter::paintPageOnPainter( &p, m_document->page(0), dummyDocumentObserver, 0, 3, 2, QRect(0, 0, 3, 2) );
 
 	// Verify pixel data
 	QCOMPARE( img.pixel(0, 0), qRgb(0, 0, 0) );
 	QCOMPARE( img.pixel(2, 1), qRgb(255, 255, 255) );
 
 	m_document->removeObserver( dummyDocumentObserver );
 	delete dummyDocumentObserver;
 	delete m_document;
 }
 
 QTEST_MAIN(KIMGIOTest)
 #include "kimgiotest.moc"
diff --git a/generators/poppler/generator_pdf.cpp b/generators/poppler/generator_pdf.cpp
index 4678823e7..42ccb3a26 100644
--- a/generators/poppler/generator_pdf.cpp
+++ b/generators/poppler/generator_pdf.cpp
@@ -1,1719 +1,1718 @@
 /***************************************************************************
  *   Copyright (C) 2004-2008 by Albert Astals Cid <aacid@kde.org>          *
  *   Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>                  *
  *   Copyright (C) 2012 by Guillermo A. Amaral B. <gamaral@kde.org>        *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "generator_pdf.h"
 
 // qt/kde includes
 #include <qcheckbox.h>
 #include <qcolor.h>
 #include <qdir.h>
 #include <qfile.h>
 #include <qimage.h>
 #include <qlayout.h>
 #include <qmutex.h>
 #include <qregexp.h>
 #include <qstack.h>
 #include <qtemporaryfile.h>
 #include <qtextstream.h>
 #include <QPrinter>
 #include <QPainter>
 #include <QtCore/QDebug>
 
 #include <KAboutData>
 #include <kconfigdialog.h>
 #include <KLocalizedString>
 #include <kmessagebox.h>
 
 #include <core/action.h>
 #include <core/page.h>
 #include <core/annotations.h>
 #include <core/movie.h>
 #include <core/pagetransition.h>
 #include <core/sound.h>
 #include <core/sourcereference.h>
 #include <core/textpage.h>
 #include <core/fileprinter.h>
 #include <core/utils.h>
 
 #include "ui_pdfsettingswidget.h"
 #include "pdfsettings.h"
 
 #include <config-okular-poppler.h>
 
 #include <poppler-media.h>
 
 #include "debug_pdf.h"
 #include "annots.h"
 #include "formfields.h"
 #include "popplerembeddedfile.h"
 
 Q_DECLARE_METATYPE(Poppler::Annotation*)
 Q_DECLARE_METATYPE(Poppler::FontInfo)
 Q_DECLARE_METATYPE(const Poppler::LinkMovie*)
 Q_DECLARE_METATYPE(const Poppler::LinkRendition*)
 #ifdef HAVE_POPPLER_0_50
 Q_DECLARE_METATYPE(const Poppler::LinkOCGState*)
 #endif
 
 static const int defaultPageWidth = 595;
 static const int defaultPageHeight = 842;
 
 class PDFOptionsPage : public QWidget
 {
     Q_OBJECT
 
    public:
        PDFOptionsPage()
        {
            setWindowTitle( i18n( "PDF Options" ) );
            QVBoxLayout *layout = new QVBoxLayout(this);
            m_printAnnots = new QCheckBox(i18n("Print annotations"), this);
            m_printAnnots->setToolTip(i18n("Include annotations in the printed document"));
            m_printAnnots->setWhatsThis(i18n("Includes annotations in the printed document. You can disable this if you want to print the original unannotated document."));
            layout->addWidget(m_printAnnots);
            m_forceRaster = new QCheckBox(i18n("Force rasterization"), this);
            m_forceRaster->setToolTip(i18n("Rasterize into an image before printing"));
            m_forceRaster->setWhatsThis(i18n("Forces the rasterization of each page into an image before printing it. This usually gives somewhat worse results, but is useful when printing documents that appear to print incorrectly."));
            layout->addWidget(m_forceRaster);
            layout->addStretch(1);
 
 #if defined(Q_OS_WIN)
            m_printAnnots->setVisible( false );
 #endif
            setPrintAnnots( true ); // Default value
        }
 
        bool printAnnots()
        {
            return m_printAnnots->isChecked();
        }
 
        void setPrintAnnots( bool printAnnots )
        {
            m_printAnnots->setChecked( printAnnots );
        }
 
        bool printForceRaster()
        {
            return m_forceRaster->isChecked();
        }
 
        void setPrintForceRaster( bool forceRaster )
        {
            m_forceRaster->setChecked( forceRaster );
        }
 
     private:
         QCheckBox *m_printAnnots;
         QCheckBox *m_forceRaster;
 };
 
 
 static void fillViewportFromLinkDestination( Okular::DocumentViewport &viewport, const Poppler::LinkDestination &destination )
 {
     viewport.pageNumber = destination.pageNumber() - 1;
 
     if (!viewport.isValid()) return;
 
     // get destination position
     // TODO add other attributes to the viewport (taken from link)
 //     switch ( destination->getKind() )
 //     {
 //         case destXYZ:
             if (destination.isChangeLeft() || destination.isChangeTop())
             {
                 // TODO remember to change this if we implement DPI and/or rotation
                 double left, top;
                 left = destination.left();
                 top = destination.top();
 
                 viewport.rePos.normalizedX = left;
                 viewport.rePos.normalizedY = top;
                 viewport.rePos.enabled = true;
                 viewport.rePos.pos = Okular::DocumentViewport::TopLeft;
             }
             /* TODO
             if ( dest->getChangeZoom() )
                 make zoom change*/
 /*        break;
 
         default:
             // implement the others cases
         break;*/
 //     }
 }
 
 Okular::Sound* createSoundFromPopplerSound( const Poppler::SoundObject *popplerSound )
 {
     Okular::Sound *sound = popplerSound->soundType() == Poppler::SoundObject::Embedded ? new Okular::Sound( popplerSound->data() ) : new Okular::Sound( popplerSound->url() );
     sound->setSamplingRate( popplerSound->samplingRate() );
     sound->setChannels( popplerSound->channels() );
     sound->setBitsPerSample( popplerSound->bitsPerSample() );
     switch ( popplerSound->soundEncoding() )
     {
         case Poppler::SoundObject::Raw:
             sound->setSoundEncoding( Okular::Sound::Raw );
             break;
         case Poppler::SoundObject::Signed:
             sound->setSoundEncoding( Okular::Sound::Signed );
             break;
         case Poppler::SoundObject::muLaw:
             sound->setSoundEncoding( Okular::Sound::muLaw );
             break;
         case Poppler::SoundObject::ALaw:
             sound->setSoundEncoding( Okular::Sound::ALaw );
             break;
     }
     return sound;
 }
 
 Okular::Movie* createMovieFromPopplerMovie( const Poppler::MovieObject *popplerMovie )
 {
     Okular::Movie *movie = new Okular::Movie( popplerMovie->url() );
     movie->setSize( popplerMovie->size() );
     movie->setRotation( (Okular::Rotation)( popplerMovie->rotation() / 90 ) );
     movie->setShowControls( popplerMovie->showControls() );
     movie->setPlayMode( (Okular::Movie::PlayMode)popplerMovie->playMode() );
     movie->setAutoPlay( false ); // will be triggered by external MovieAnnotation
     movie->setShowPosterImage( popplerMovie->showPosterImage() );
     movie->setPosterImage( popplerMovie->posterImage() );
     return movie;
 }
 
 Okular::Movie* createMovieFromPopplerScreen( const Poppler::LinkRendition *popplerScreen )
 {
     Poppler::MediaRendition *rendition = popplerScreen->rendition();
     Okular::Movie *movie = 0;
     if ( rendition->isEmbedded() )
         movie = new Okular::Movie( rendition->fileName(), rendition->data() );
     else
         movie = new Okular::Movie( rendition->fileName() );
     movie->setSize( rendition->size() );
     movie->setShowControls( rendition->showControls() );
     if ( rendition->repeatCount() == 0 ) {
         movie->setPlayMode( Okular::Movie::PlayRepeat );
     } else {
         movie->setPlayMode( Okular::Movie::PlayLimited );
         movie->setPlayRepetitions( rendition->repeatCount() );
     }
     movie->setAutoPlay( rendition->autoPlay() );
     return movie;
 }
 
 #ifdef HAVE_POPPLER_0_36
 QPair<Okular::Movie*, Okular::EmbeddedFile*> createMovieFromPopplerRichMedia( const Poppler::RichMediaAnnotation *popplerRichMedia )
 {
     const QPair<Okular::Movie*, Okular::EmbeddedFile*> emptyResult(0, 0);
 
     /**
      * To convert a Flash/Video based RichMedia annotation to a movie, we search for the first
      * Flash/Video richmedia instance and parse the flashVars parameter for the 'source' identifier.
      * That identifier is then used to find the associated embedded file through the assets
      * mapping.
      */
     const Poppler::RichMediaAnnotation::Content *content = popplerRichMedia->content();
     if ( !content )
         return emptyResult;
 
     const QList<Poppler::RichMediaAnnotation::Configuration*> configurations = content->configurations();
     if ( configurations.isEmpty() )
         return emptyResult;
 
     const Poppler::RichMediaAnnotation::Configuration *configuration = configurations[0];
 
     const QList<Poppler::RichMediaAnnotation::Instance*> instances = configuration->instances();
     if ( instances.isEmpty() )
         return emptyResult;
 
     const Poppler::RichMediaAnnotation::Instance *instance = instances[0];
 
     if ( ( instance->type() != Poppler::RichMediaAnnotation::Instance::TypeFlash ) &&
          ( instance->type() != Poppler::RichMediaAnnotation::Instance::TypeVideo ) )
         return emptyResult;
 
     const Poppler::RichMediaAnnotation::Params *params = instance->params();
     if ( !params )
         return emptyResult;
 
     QString sourceId;
     bool playbackLoops = false;
 
     const QStringList flashVars = params->flashVars().split( QLatin1Char( '&' ) );
     foreach ( const QString & flashVar, flashVars ) {
         const int pos = flashVar.indexOf( QLatin1Char( '=' ) );
         if ( pos == -1 )
             continue;
 
         const QString key = flashVar.left( pos );
         const QString value = flashVar.mid( pos + 1 );
 
         if ( key == QLatin1String( "source" ) )
             sourceId = value;
         else if ( key == QLatin1String( "loop" ) )
             playbackLoops = ( value == QLatin1String( "true" ) ? true : false );
     }
 
     if ( sourceId.isEmpty() )
         return emptyResult;
 
     const QList<Poppler::RichMediaAnnotation::Asset*> assets = content->assets();
     if ( assets.isEmpty() )
         return emptyResult;
 
     Poppler::RichMediaAnnotation::Asset *matchingAsset = 0;
     foreach ( Poppler::RichMediaAnnotation::Asset *asset, assets ) {
         if ( asset->name() == sourceId ) {
             matchingAsset = asset;
             break;
         }
     }
 
     if ( !matchingAsset )
         return emptyResult;
 
     Poppler::EmbeddedFile *embeddedFile = matchingAsset->embeddedFile();
     if ( !embeddedFile )
         return emptyResult;
 
     Okular::EmbeddedFile *pdfEmbeddedFile = new PDFEmbeddedFile( embeddedFile );
 
     Okular::Movie *movie = new Okular::Movie( embeddedFile->name(), embeddedFile->data() );
     movie->setPlayMode( playbackLoops ? Okular::Movie::PlayRepeat : Okular::Movie::PlayLimited );
 
     if ( popplerRichMedia && popplerRichMedia->settings() && popplerRichMedia->settings()->activation() ) {
         if ( popplerRichMedia->settings()->activation()->condition() == Poppler::RichMediaAnnotation::Activation::PageOpened ||
              popplerRichMedia->settings()->activation()->condition() == Poppler::RichMediaAnnotation::Activation::PageVisible ) {
             movie->setAutoPlay( true );
         } else {
             movie->setAutoPlay( false );
         }
 
     } else {
         movie->setAutoPlay( false );
     }
 
     return qMakePair(movie, pdfEmbeddedFile);
 }
 #endif
 
 /**
  * Note: the function will take ownership of the popplerLink object.
  */
 Okular::Action* createLinkFromPopplerLink(const Poppler::Link *popplerLink)
 {
     if (!popplerLink)
         return nullptr;
 
     Okular::Action *link = 0;
     const Poppler::LinkGoto *popplerLinkGoto;
     const Poppler::LinkExecute *popplerLinkExecute;
     const Poppler::LinkBrowse *popplerLinkBrowse;
     const Poppler::LinkAction *popplerLinkAction;
     const Poppler::LinkSound *popplerLinkSound;
     const Poppler::LinkJavaScript *popplerLinkJS;
     const Poppler::LinkMovie *popplerLinkMovie;
     const Poppler::LinkRendition *popplerLinkRendition;
     Okular::DocumentViewport viewport;
 
     bool deletePopplerLink = true;
 
     switch(popplerLink->linkType())
     {
         case Poppler::Link::None:
         break;
 
         case Poppler::Link::Goto:
         {
             popplerLinkGoto = static_cast<const Poppler::LinkGoto *>(popplerLink);
             const Poppler::LinkDestination dest = popplerLinkGoto->destination();
             const QString destName = dest.destinationName();
             if (destName.isEmpty())
             {
                 fillViewportFromLinkDestination( viewport, dest );
                 link = new Okular::GotoAction(popplerLinkGoto->fileName(), viewport);
             }
             else
             {
                 link = new Okular::GotoAction(popplerLinkGoto->fileName(), destName);
             }
         }
         break;
 
         case Poppler::Link::Execute:
             popplerLinkExecute = static_cast<const Poppler::LinkExecute *>(popplerLink);
             link = new Okular::ExecuteAction( popplerLinkExecute->fileName(), popplerLinkExecute->parameters() );
         break;
 
         case Poppler::Link::Browse:
             popplerLinkBrowse = static_cast<const Poppler::LinkBrowse *>(popplerLink);
             link = new Okular::BrowseAction( QUrl(popplerLinkBrowse->url()) );
         break;
 
         case Poppler::Link::Action:
             popplerLinkAction = static_cast<const Poppler::LinkAction *>(popplerLink);
             link = new Okular::DocumentAction( (Okular::DocumentAction::DocumentActionType)popplerLinkAction->actionType() );
         break;
 
         case Poppler::Link::Sound:
         {
             popplerLinkSound = static_cast<const Poppler::LinkSound *>(popplerLink);
             Poppler::SoundObject *popplerSound = popplerLinkSound->sound();
             Okular::Sound *sound = createSoundFromPopplerSound( popplerSound );
             link = new Okular::SoundAction( popplerLinkSound->volume(), popplerLinkSound->synchronous(), popplerLinkSound->repeat(), popplerLinkSound->mix(), sound );
         }
         break;
 
         case Poppler::Link::JavaScript:
         {
             popplerLinkJS = static_cast<const Poppler::LinkJavaScript *>(popplerLink);
             link = new Okular::ScriptAction( Okular::JavaScript, popplerLinkJS->script() );
         }
         break;
 
         case Poppler::Link::Rendition:
         {
             deletePopplerLink = false; // we'll delete it inside resolveMediaLinkReferences() after we have resolved all references
 
             popplerLinkRendition = static_cast<const Poppler::LinkRendition *>( popplerLink );
 
             Okular::RenditionAction::OperationType operation = Okular::RenditionAction::None;
             switch ( popplerLinkRendition->action() )
             {
                 case Poppler::LinkRendition::NoRendition:
                     operation = Okular::RenditionAction::None;
                     break;
                 case Poppler::LinkRendition::PlayRendition:
                     operation = Okular::RenditionAction::Play;
                     break;
                 case Poppler::LinkRendition::StopRendition:
                     operation = Okular::RenditionAction::Stop;
                     break;
                 case Poppler::LinkRendition::PauseRendition:
                     operation = Okular::RenditionAction::Pause;
                     break;
                 case Poppler::LinkRendition::ResumeRendition:
                     operation = Okular::RenditionAction::Resume;
                     break;
             };
 
             Okular::Movie *movie = 0;
             if ( popplerLinkRendition->rendition() )
                 movie = createMovieFromPopplerScreen( popplerLinkRendition );
 
             Okular::RenditionAction *renditionAction = new Okular::RenditionAction( operation, movie, Okular::JavaScript, popplerLinkRendition->script() );
             renditionAction->setNativeId( QVariant::fromValue( popplerLinkRendition ) );
             link = renditionAction;
         }
         break;
 
         case Poppler::Link::Movie:
         {
             deletePopplerLink = false; // we'll delete it inside resolveMediaLinkReferences() after we have resolved all references
 
             popplerLinkMovie = static_cast<const Poppler::LinkMovie *>( popplerLink );
 
             Okular::MovieAction::OperationType operation = Okular::MovieAction::Play;
             switch ( popplerLinkMovie->operation() )
             {
                 case Poppler::LinkMovie::Play:
                     operation = Okular::MovieAction::Play;
                     break;
                 case Poppler::LinkMovie::Stop:
                     operation = Okular::MovieAction::Stop;
                     break;
                 case Poppler::LinkMovie::Pause:
                     operation = Okular::MovieAction::Pause;
                     break;
                 case Poppler::LinkMovie::Resume:
                     operation = Okular::MovieAction::Resume;
                     break;
             };
 
             Okular::MovieAction *movieAction = new Okular::MovieAction( operation );
             movieAction->setNativeId( QVariant::fromValue( popplerLinkMovie ) );
             link = movieAction;
         }
         break;
     }
 
     if ( deletePopplerLink )
         delete popplerLink;
 
     return link;
 }
 
 /**
  * Note: the function will take ownership of the popplerLink objects.
  */
 static QLinkedList<Okular::ObjectRect*> generateLinks( const QList<Poppler::Link*> &popplerLinks )
 {
     QLinkedList<Okular::ObjectRect*> links;
     foreach(const Poppler::Link *popplerLink, popplerLinks)
     {
         QRectF linkArea = popplerLink->linkArea();
         double nl = linkArea.left(),
                nt = linkArea.top(),
                nr = linkArea.right(),
                nb = linkArea.bottom();
         // create the rect using normalized coords and attach the Okular::Link to it
         Okular::ObjectRect * rect = new Okular::ObjectRect( nl, nt, nr, nb, false, Okular::ObjectRect::Action, createLinkFromPopplerLink(popplerLink) );
         // add the ObjectRect to the container
         links.push_front( rect );
     }
     return links;
 }
 
 /** NOTES on threading:
  * internal: thread race prevention is done via the 'docLock' mutex. the
  *           mutex is needed only because we have the asynchronous thread; else
  *           the operations are all within the 'gui' thread, scheduled by the
  *           Qt scheduler and no mutex is needed.
  * external: dangerous operations are all locked via mutex internally, and the
  *           only needed external thing is the 'canGeneratePixmap' method
  *           that tells if the generator is free (since we don't want an
  *           internal queue to store PixmapRequests). A generatedPixmap call
  *           without the 'ready' flag set, results in undefined behavior.
  * So, as example, printing while generating a pixmap asynchronously is safe,
  * it might only block the gui thread by 1) waiting for the mutex to unlock
  * in async thread and 2) doing the 'heavy' print operation.
  */
 
 OKULAR_EXPORT_PLUGIN(PDFGenerator, "libokularGenerator_poppler.json")
 
 static void PDFGeneratorPopplerDebugFunction(const QString &message, const QVariant &closure)
 {
     Q_UNUSED(closure);
     qCDebug(OkularPdfDebug) << "[Poppler]" << message;
 }
 
 PDFGenerator::PDFGenerator( QObject *parent, const QVariantList &args )
     : Generator( parent, args ), pdfdoc( 0 ),
     docSynopsisDirty( true ),
     docEmbeddedFilesDirty( true ), nextFontPage( 0 ),
     annotProxy( 0 )
 {
     setFeature( Threaded );
     setFeature( TextExtraction );
     setFeature( FontInfo );
 #ifdef Q_OS_WIN32
     setFeature( PrintNative );
 #else
     setFeature( PrintPostscript );
 #endif
     if ( Okular::FilePrinter::ps2pdfAvailable() )
         setFeature( PrintToFile );
     setFeature( ReadRawData );
     setFeature( TiledRendering );
 
     // You only need to do it once not for each of the documents but it is cheap enough
     // so doing it all the time won't hurt either
     Poppler::setDebugErrorFunction(PDFGeneratorPopplerDebugFunction, QVariant());
 }
 
 PDFGenerator::~PDFGenerator()
 {
     delete pdfOptionsPage;
 }
 
 //BEGIN Generator inherited functions
 Okular::Document::OpenResult PDFGenerator::loadDocumentWithPassword( const QString & filePath, QVector<Okular::Page*> & pagesVector, const QString &password )
 {
 #ifndef NDEBUG
     if ( pdfdoc )
     {
         qCDebug(OkularPdfDebug) << "PDFGenerator: multiple calls to loadDocument. Check it.";
         return Okular::Document::OpenError;
     }
 #endif
     // create PDFDoc for the given file
     pdfdoc = Poppler::Document::load( filePath, 0, 0 );
     return init(pagesVector, password);
 }
 
 Okular::Document::OpenResult PDFGenerator::loadDocumentFromDataWithPassword( const QByteArray & fileData, QVector<Okular::Page*> & pagesVector, const QString &password )
 {
 #ifndef NDEBUG
     if ( pdfdoc )
     {
         qCDebug(OkularPdfDebug) << "PDFGenerator: multiple calls to loadDocument. Check it.";
         return Okular::Document::OpenError;
     }
 #endif
     // create PDFDoc for the given file
     pdfdoc = Poppler::Document::loadFromData( fileData, 0, 0 );
     return init(pagesVector, password);
 }
 
 Okular::Document::OpenResult PDFGenerator::init(QVector<Okular::Page*> & pagesVector, const QString &password)
 {
     if ( !pdfdoc )
         return Okular::Document::OpenError;
 
     if ( pdfdoc->isLocked() )
     {
         pdfdoc->unlock( password.toLatin1(), password.toLatin1() );
 
         if ( pdfdoc->isLocked() ) {
             delete pdfdoc;
             pdfdoc = 0;
             return Okular::Document::OpenNeedsPassword;
         }
     }
 
     // build Pages (currentPage was set -1 by deletePages)
     int pageCount = pdfdoc->numPages();
     if (pageCount < 0) {
         delete pdfdoc;
         pdfdoc = 0;
         return Okular::Document::OpenError;
     }
     pagesVector.resize(pageCount);
     rectsGenerated.fill(false, pageCount);
 
     annotationsHash.clear();
 
     loadPages(pagesVector, 0, false);
 
     // update the configuration
     reparseConfig();
 
     // create annotation proxy
     annotProxy = new PopplerAnnotationProxy( pdfdoc, userMutex() );
 
     // the file has been loaded correctly
     return Okular::Document::OpenSuccess;
 }
 
 bool PDFGenerator::doCloseDocument()
 {
     // remove internal objects
     userMutex()->lock();
     delete annotProxy;
     annotProxy = 0;
     delete pdfdoc;
     pdfdoc = 0;
     userMutex()->unlock();
     docSynopsisDirty = true;
     docSyn.clear();
     docEmbeddedFilesDirty = true;
     qDeleteAll(docEmbeddedFiles);
     docEmbeddedFiles.clear();
     nextFontPage = 0;
     rectsGenerated.clear();
 
     return true;
 }
 
 void PDFGenerator::loadPages(QVector<Okular::Page*> &pagesVector, int rotation, bool clear)
 {
     // TODO XPDF 3.01 check
     const int count = pagesVector.count();
     double w = 0, h = 0;
     for ( int i = 0; i < count ; i++ )
     {
         // get xpdf page
         Poppler::Page * p = pdfdoc->page( i );
         Okular::Page * page;
         if (p)
         {
             const QSizeF pSize = p->pageSizeF();
             w = pSize.width() / 72.0 * dpi().width();
             h = pSize.height() / 72.0 * dpi().height();
-
             Okular::Rotation orientation = Okular::Rotation0;
             switch (p->orientation())
             {
             case Poppler::Page::Landscape: orientation = Okular::Rotation90; break;
             case Poppler::Page::UpsideDown: orientation = Okular::Rotation180; break;
             case Poppler::Page::Seascape: orientation = Okular::Rotation270; break;
             case Poppler::Page::Portrait: orientation = Okular::Rotation0; break;
             }
             if (rotation % 2 == 1)
             qSwap(w,h);
             // init a Okular::page, add transition and annotation information
             page = new Okular::Page( i, w, h, orientation );
             addTransition( p, page );
             if ( true ) //TODO real check
             addAnnotations( p, page );
             Poppler::Link * tmplink = p->action( Poppler::Page::Opening );
             if ( tmplink )
             {
                 page->setPageAction( Okular::Page::Opening, createLinkFromPopplerLink( tmplink ) );
             }
             tmplink = p->action( Poppler::Page::Closing );
             if ( tmplink )
             {
                 page->setPageAction( Okular::Page::Closing, createLinkFromPopplerLink( tmplink ) );
             }
             page->setDuration( p->duration() );
             page->setLabel( p->label() );
 
             addFormFields( p, page );
 //        kWarning(PDFDebug).nospace() << page->width() << "x" << page->height();
 
 #ifdef PDFGENERATOR_DEBUG
             qCDebug(OkularPdfDebug) << "load page" << i << "with rotation" << rotation << "and orientation" << orientation;
 #endif
             delete p;
 
             if (clear && pagesVector[i])
                 delete pagesVector[i];
         }
         else
         {
             page = new Okular::Page( i, defaultPageWidth, defaultPageHeight, Okular::Rotation0 );
         }
         // set the Okular::page at the right position in document's pages vector
         pagesVector[i] = page;
     }
 }
 
 Okular::DocumentInfo PDFGenerator::generateDocumentInfo( const QSet<Okular::DocumentInfo::Key> &keys ) const
 {
     Okular::DocumentInfo docInfo;
     docInfo.set( Okular::DocumentInfo::MimeType, QStringLiteral("application/pdf") );
 
     userMutex()->lock();
 
 
     if ( pdfdoc )
     {
         // compile internal structure reading properties from PDFDoc
         if ( keys.contains( Okular::DocumentInfo::Title ) )
             docInfo.set( Okular::DocumentInfo::Title, pdfdoc->info(QStringLiteral("Title")) );
         if ( keys.contains( Okular::DocumentInfo::Subject ) )
             docInfo.set( Okular::DocumentInfo::Subject, pdfdoc->info(QStringLiteral("Subject")) );
         if ( keys.contains( Okular::DocumentInfo::Author ) )
             docInfo.set( Okular::DocumentInfo::Author, pdfdoc->info(QStringLiteral("Author")) );
         if ( keys.contains( Okular::DocumentInfo::Keywords ) )
             docInfo.set( Okular::DocumentInfo::Keywords, pdfdoc->info(QStringLiteral("Keywords")) );
         if ( keys.contains( Okular::DocumentInfo::Creator ) )
             docInfo.set( Okular::DocumentInfo::Creator, pdfdoc->info(QStringLiteral("Creator")) );
         if ( keys.contains( Okular::DocumentInfo::Producer ) )
             docInfo.set( Okular::DocumentInfo::Producer, pdfdoc->info(QStringLiteral("Producer")) );
         if ( keys.contains( Okular::DocumentInfo::CreationDate ) )
             docInfo.set( Okular::DocumentInfo::CreationDate, QLocale().toString( pdfdoc->date(QStringLiteral("CreationDate")), QLocale::LongFormat ) );
         if ( keys.contains( Okular::DocumentInfo::ModificationDate ) )
             docInfo.set( Okular::DocumentInfo::ModificationDate, QLocale().toString( pdfdoc->date(QStringLiteral("ModDate")), QLocale::LongFormat ) );
         if ( keys.contains( Okular::DocumentInfo::CustomKeys ) )
         {
             int major, minor;
             pdfdoc->getPdfVersion(&major, &minor);
             docInfo.set( QStringLiteral("format"), i18nc( "PDF v. <version>", "PDF v. %1.%2", major, minor ), i18n( "Format" ) );
             docInfo.set( QStringLiteral("encryption"), pdfdoc->isEncrypted() ? i18n( "Encrypted" ) : i18n( "Unencrypted" ), i18n("Security") );
             docInfo.set( QStringLiteral("optimization"), pdfdoc->isLinearized() ? i18n( "Yes" ) : i18n( "No" ), i18n("Optimized") );
         }
 
         docInfo.set( Okular::DocumentInfo::Pages, QString::number( pdfdoc->numPages() ) );
     }
     userMutex()->unlock();
 
     return docInfo;
 }
 
 const Okular::DocumentSynopsis * PDFGenerator::generateDocumentSynopsis()
 {
     if ( !docSynopsisDirty )
         return &docSyn;
 
     if ( !pdfdoc )
         return NULL;
 
     userMutex()->lock();
     QDomDocument *toc = pdfdoc->toc();
     userMutex()->unlock();
     if ( !toc )
         return NULL;
 
     addSynopsisChildren(toc, &docSyn);
     delete toc;
 
     docSynopsisDirty = false;
     return &docSyn;
 }
 
 static Okular::FontInfo::FontType convertPopplerFontInfoTypeToOkularFontInfoType( Poppler::FontInfo::Type type )
 {
     switch ( type )
     {
         case Poppler::FontInfo::Type1:
             return Okular::FontInfo::Type1;
             break;
         case Poppler::FontInfo::Type1C:
             return Okular::FontInfo::Type1C;
             break;
         case Poppler::FontInfo::Type3:
             return Okular::FontInfo::Type3;
             break;
         case Poppler::FontInfo::TrueType:
             return Okular::FontInfo::TrueType;
             break;
         case Poppler::FontInfo::CIDType0:
             return Okular::FontInfo::CIDType0;
             break;
         case Poppler::FontInfo::CIDType0C:
             return Okular::FontInfo::CIDType0C;
             break;
         case Poppler::FontInfo::CIDTrueType:
             return Okular::FontInfo::CIDTrueType;
             break;
         case Poppler::FontInfo::Type1COT:
             return Okular::FontInfo::Type1COT;
             break;
         case Poppler::FontInfo::TrueTypeOT:
             return Okular::FontInfo::TrueTypeOT;
             break;
         case Poppler::FontInfo::CIDType0COT:
             return Okular::FontInfo::CIDType0COT;
             break;
         case Poppler::FontInfo::CIDTrueTypeOT:
             return Okular::FontInfo::CIDTrueTypeOT;
             break;
         case Poppler::FontInfo::unknown:
         default: ;
      }
      return Okular::FontInfo::Unknown;
 }
 
 static Okular::FontInfo::EmbedType embedTypeForPopplerFontInfo( const Poppler::FontInfo &fi )
 {
     Okular::FontInfo::EmbedType ret = Okular::FontInfo::NotEmbedded;
     if ( fi.isEmbedded() )
     {
         if ( fi.isSubset() )
         {
             ret = Okular::FontInfo::EmbeddedSubset;
         }
         else
         {
             ret = Okular::FontInfo::FullyEmbedded;
         }
     }
      return ret;
 }
 
 Okular::FontInfo::List PDFGenerator::fontsForPage( int page )
 {
     Okular::FontInfo::List list;
 
     if ( page != nextFontPage )
         return list;
 
     QList<Poppler::FontInfo> fonts;
     userMutex()->lock();
 
     Poppler::FontIterator* it = pdfdoc->newFontIterator(page);
     if (it->hasNext()) {
         fonts = it->next();
     }
     userMutex()->unlock();
 
     foreach (const Poppler::FontInfo &font, fonts)
     {
         Okular::FontInfo of;
         of.setName( font.name() );
         of.setType( convertPopplerFontInfoTypeToOkularFontInfoType( font.type() ) );
         of.setEmbedType( embedTypeForPopplerFontInfo( font) );
         of.setFile( font.file() );
         of.setCanBeExtracted( of.embedType() != Okular::FontInfo::NotEmbedded );
 
         QVariant nativeId;
         nativeId.setValue( font );
         of.setNativeId( nativeId );
 
         list.append( of );
     }
 
     ++nextFontPage;
 
     return list;
 }
 
 const QList<Okular::EmbeddedFile*> *PDFGenerator::embeddedFiles() const
 {
     if (docEmbeddedFilesDirty)
     {
         userMutex()->lock();
         const QList<Poppler::EmbeddedFile*> &popplerFiles = pdfdoc->embeddedFiles();
         foreach(Poppler::EmbeddedFile* pef, popplerFiles)
         {
             docEmbeddedFiles.append(new PDFEmbeddedFile(pef));
         }
         userMutex()->unlock();
 
         docEmbeddedFilesDirty = false;
     }
 
     return &docEmbeddedFiles;
 }
 
 QAbstractItemModel* PDFGenerator::layersModel() const
 {
     return pdfdoc->hasOptionalContent() ? pdfdoc->optionalContentModel() : NULL;
 }
 
 void PDFGenerator::opaqueAction( const Okular::BackendOpaqueAction *action )
 {
 #ifdef HAVE_POPPLER_0_50
     const Poppler::LinkOCGState *popplerLink = action->nativeId().value<const Poppler::LinkOCGState *>();
     pdfdoc->optionalContentModel()->applyLink( const_cast< Poppler::LinkOCGState* >( popplerLink ) );
 #else
     (void)action;
 #endif
 }
 
 bool PDFGenerator::isAllowed( Okular::Permission permission ) const
 {
     bool b = true;
     switch ( permission )
     {
         case Okular::AllowModify:
             b = pdfdoc->okToChange();
             break;
         case Okular::AllowCopy:
             b = pdfdoc->okToCopy();
             break;
         case Okular::AllowPrint:
             b = pdfdoc->okToPrint();
             break;
         case Okular::AllowNotes:
             b = pdfdoc->okToAddNotes();
             break;
         case Okular::AllowFillForms:
             b = pdfdoc->okToFillForm();
             break;
         default: ;
     }
     return b;
 }
 
 QImage PDFGenerator::image( Okular::PixmapRequest * request )
 {
     // debug requests to this (xpdf) generator
     //qCDebug(OkularPdfDebug) << "id: " << request->id << " is requesting " << (request->async ? "ASYNC" : "sync") <<  " pixmap for page " << request->page->number() << " [" << request->width << " x " << request->height << "].";
 
     // compute dpi used to get an image with desired width and height
     Okular::Page * page = request->page();
 
     double pageWidth = page->width(),
            pageHeight = page->height();
 
     if ( page->rotation() % 2 )
         qSwap( pageWidth, pageHeight );
 
     qreal fakeDpiX = request->width() / pageWidth * dpi().width();
     qreal fakeDpiY = request->height() / pageHeight * dpi().height();
 
     // generate links rects only the first time
     bool genObjectRects = !rectsGenerated.at( page->number() );
 
     // 0. LOCK [waits for the thread end]
     userMutex()->lock();
 
     // 1. Set OutputDev parameters and Generate contents
     // note: thread safety is set on 'false' for the GUI (this) thread
     Poppler::Page *p = pdfdoc->page(page->number());
 
     // 2. Take data from outputdev and attach it to the Page
     QImage img;
     if (p)
     {
         if ( request->isTile() )
         {
             QRect rect = request->normalizedRect().geometry( request->width(), request->height() );
             img = p->renderToImage( fakeDpiX, fakeDpiY, rect.x(), rect.y(), rect.width(), rect.height(), Poppler::Page::Rotate0 );
         }
         else
         {
             img = p->renderToImage(fakeDpiX, fakeDpiY, -1, -1, -1, -1, Poppler::Page::Rotate0 );
         }
     }
     else
     {
         img = QImage( request->width(), request->height(), QImage::Format_Mono );
         img.fill( Qt::white );
     }
 
     if ( p && genObjectRects )
     {
         // TODO previously we extracted Image type rects too, but that needed porting to poppler
         // and as we are not doing anything with Image type rects i did not port it, have a look at
         // dead gp_outputdev.cpp on image extraction
         page->setObjectRects( generateLinks(p->links()) );
         rectsGenerated[ request->page()->number() ] = true;
 
         resolveMediaLinkReferences( page );
     }
 
     // 3. UNLOCK [re-enables shared access]
     userMutex()->unlock();
 
     delete p;
 
     return img;
 }
 
 template <typename PopplerLinkType, typename OkularLinkType, typename PopplerAnnotationType, typename OkularAnnotationType>
 void resolveMediaLinks( Okular::Action *action, enum Okular::Annotation::SubType subType, QHash<Okular::Annotation*, Poppler::Annotation*> &annotationsHash )
 {
     OkularLinkType *okularAction = static_cast<OkularLinkType*>( action );
 
     const PopplerLinkType *popplerLink = action->nativeId().value<const PopplerLinkType*>();
 
     QHashIterator<Okular::Annotation*, Poppler::Annotation*> it( annotationsHash );
     while ( it.hasNext() )
     {
         it.next();
 
         if ( it.key()->subType() == subType )
         {
             const PopplerAnnotationType *popplerAnnotation = static_cast<const PopplerAnnotationType*>( it.value() );
 
             if ( popplerLink->isReferencedAnnotation( popplerAnnotation ) )
             {
                 okularAction->setAnnotation( static_cast<OkularAnnotationType*>( it.key() ) );
                 okularAction->setNativeId( QVariant() );
                 delete popplerLink; // delete the associated Poppler::LinkMovie object, it's not needed anymore
                 break;
             }
         }
     }
 }
 
 void PDFGenerator::resolveMediaLinkReference( Okular::Action *action )
 {
     if ( !action )
         return;
 
     if ( (action->actionType() != Okular::Action::Movie) && (action->actionType() != Okular::Action::Rendition) )
         return;
 
     resolveMediaLinks<Poppler::LinkMovie, Okular::MovieAction, Poppler::MovieAnnotation, Okular::MovieAnnotation>( action, Okular::Annotation::AMovie, annotationsHash );
     resolveMediaLinks<Poppler::LinkRendition, Okular::RenditionAction, Poppler::ScreenAnnotation, Okular::ScreenAnnotation>( action, Okular::Annotation::AScreen, annotationsHash );
 }
 
 void PDFGenerator::resolveMediaLinkReferences( Okular::Page *page )
 {
     resolveMediaLinkReference( const_cast<Okular::Action*>( page->pageAction( Okular::Page::Opening ) ) );
     resolveMediaLinkReference( const_cast<Okular::Action*>( page->pageAction( Okular::Page::Closing ) ) );
 
     foreach ( Okular::Annotation *annotation, page->annotations() )
     {
         if ( annotation->subType() == Okular::Annotation::AScreen )
         {
             Okular::ScreenAnnotation *screenAnnotation = static_cast<Okular::ScreenAnnotation*>( annotation );
             resolveMediaLinkReference( screenAnnotation->additionalAction( Okular::Annotation::PageOpening ) );
             resolveMediaLinkReference( screenAnnotation->additionalAction( Okular::Annotation::PageClosing ) );
         }
 
         if ( annotation->subType() == Okular::Annotation::AWidget )
         {
             Okular::WidgetAnnotation *widgetAnnotation = static_cast<Okular::WidgetAnnotation*>( annotation );
             resolveMediaLinkReference( widgetAnnotation->additionalAction( Okular::Annotation::PageOpening ) );
             resolveMediaLinkReference( widgetAnnotation->additionalAction( Okular::Annotation::PageClosing ) );
         }
     }
 
     foreach ( Okular::FormField *field, page->formFields() )
         resolveMediaLinkReference( field->activationAction() );
 }
 
 Okular::TextPage* PDFGenerator::textPage( Okular::Page *page )
 {
 #ifdef PDFGENERATOR_DEBUG
     qCDebug(OkularPdfDebug) << "page" << page->number();
 #endif
     // build a TextList...
     QList<Poppler::TextBox*> textList;
     double pageWidth, pageHeight;
     Poppler::Page *pp = pdfdoc->page( page->number() );
     if (pp)
     {
         userMutex()->lock();
         textList = pp->textList();
         userMutex()->unlock();
 
         QSizeF s = pp->pageSizeF();
         pageWidth = s.width();
         pageHeight = s.height();
 
         delete pp;
     }
     else
     {
         pageWidth = defaultPageWidth;
         pageHeight = defaultPageHeight;
     }
 
     Okular::TextPage *tp = abstractTextPage(textList, pageHeight, pageWidth, (Poppler::Page::Rotation)page->orientation());
     qDeleteAll(textList);
     return tp;
 }
 
 void PDFGenerator::requestFontData(const Okular::FontInfo &font, QByteArray *data)
 {
     Poppler::FontInfo fi = font.nativeId().value<Poppler::FontInfo>();
     *data = pdfdoc->fontData(fi);
 }
 
 #define DUMMY_QPRINTER_COPY
 bool PDFGenerator::print( QPrinter& printer )
 {
 #ifdef Q_OS_WIN
     QPainter painter;
     painter.begin(&printer);
 
     QList<int> pageList = Okular::FilePrinter::pageList( printer, pdfdoc->numPages(),
                                                          document()->currentPage() + 1,
                                                          document()->bookmarkedPageList() );
     for ( int i = 0; i < pageList.count(); ++i )
     {
         if ( i != 0 )
             printer.newPage();
 
         const int page = pageList.at( i ) - 1;
         userMutex()->lock();
         Poppler::Page *pp = pdfdoc->page( page );
         if (pp)
         {
             QImage img = pp->renderToImage(  printer.physicalDpiX(), printer.physicalDpiY() );
             painter.drawImage( painter.window(), img, QRectF(0, 0, img.width(), img.height()) );
             delete pp;
         }
         userMutex()->unlock();
     }
     painter.end();
     return true;
 
 #else
 #ifdef DUMMY_QPRINTER_COPY
     // Get the real page size to pass to the ps generator
     QPrinter dummy( QPrinter::PrinterResolution );
     dummy.setFullPage( true );
     dummy.setOrientation( printer.orientation() );
     dummy.setPageSize( printer.pageSize() );
     dummy.setPaperSize( printer.paperSize( QPrinter::Millimeter ), QPrinter::Millimeter );
     int width = dummy.width();
     int height = dummy.height();
 #else
     int width = printer.width();
     int height = printer.height();
 #endif
 
     if (width <= 0 || height <= 0)
     {
         lastPrintError = InvalidPageSizePrintError;
         return false;
     }
 
     // Create the tempfile to send to FilePrinter, which will manage the deletion
     QTemporaryFile tf(QDir::tempPath() + QLatin1String("/okular_XXXXXX.ps"));
     if ( !tf.open() )
     {
         lastPrintError = TemporaryFileOpenPrintError;
         return false;
     }
     QString tempfilename = tf.fileName();
 
     // Generate the list of pages to be printed as selected in the print dialog
     QList<int> pageList = Okular::FilePrinter::pageList( printer, pdfdoc->numPages(),
                                                          document()->currentPage() + 1,
                                                          document()->bookmarkedPageList() );
 
     // TODO rotation
 
     tf.setAutoRemove(false);
 
     QString pstitle = metaData(QStringLiteral("Title"), QVariant()).toString();
     if ( pstitle.trimmed().isEmpty() )
     {
         pstitle = document()->currentDocument().fileName();
     }
 
     bool printAnnots = true;
     bool forceRasterize = false;
     if ( pdfOptionsPage )
     {
         printAnnots = pdfOptionsPage->printAnnots();
         forceRasterize = pdfOptionsPage->printForceRaster();
     }
 
     Poppler::PSConverter *psConverter = pdfdoc->psConverter();
 
     psConverter->setOutputDevice(&tf);
 
     psConverter->setPageList(pageList);
     psConverter->setPaperWidth(width);
     psConverter->setPaperHeight(height);
     psConverter->setRightMargin(0);
     psConverter->setBottomMargin(0);
     psConverter->setLeftMargin(0);
     psConverter->setTopMargin(0);
     psConverter->setStrictMargins(false);
     psConverter->setForceRasterize(forceRasterize);
     psConverter->setTitle(pstitle);
 
     if (!printAnnots)
         psConverter->setPSOptions(psConverter->psOptions() | Poppler::PSConverter::HideAnnotations );
 
     userMutex()->lock();
     if (psConverter->convert())
     {
         userMutex()->unlock();
         delete psConverter;
         tf.close();
         int ret = Okular::FilePrinter::printFile( printer, tempfilename,
                                                   document()->orientation(),
                                                   Okular::FilePrinter::SystemDeletesFiles,
                                                   Okular::FilePrinter::ApplicationSelectsPages,
                                                   document()->bookmarkedPageRange() );
 
         lastPrintError = Okular::FilePrinter::printError( ret );
 
         return (lastPrintError == NoPrintError);
     }
     else
     {
         lastPrintError = FileConversionPrintError;
         delete psConverter;
         userMutex()->unlock();
     }
 
     tf.close();
 
     return false;
 #endif
 }
 
 QVariant PDFGenerator::metaData( const QString & key, const QVariant & option ) const
 {
     if ( key == QLatin1String("StartFullScreen") )
     {
         QMutexLocker ml(userMutex());
         // asking for the 'start in fullscreen mode' (pdf property)
         if ( pdfdoc->pageMode() == Poppler::Document::FullScreen )
             return true;
     }
     else if ( key == QLatin1String("NamedViewport") && !option.toString().isEmpty() )
     {
         Okular::DocumentViewport viewport;
         QString optionString = option.toString();
 
         // asking for the page related to a 'named link destination'. the
         // option is the link name. @see addSynopsisChildren.
         userMutex()->lock();
         Poppler::LinkDestination *ld = pdfdoc->linkDestination( optionString );
         userMutex()->unlock();
         if ( ld )
         {
             fillViewportFromLinkDestination( viewport, *ld );
         }
         delete ld;
         if ( viewport.pageNumber >= 0 )
             return viewport.toString();
     }
     else if ( key == QLatin1String("DocumentTitle") )
     {
         userMutex()->lock();
         QString title = pdfdoc->info( QStringLiteral("Title") );
         userMutex()->unlock();
         return title;
     }
     else if ( key == QLatin1String("OpenTOC") )
     {
         QMutexLocker ml(userMutex());
         if ( pdfdoc->pageMode() == Poppler::Document::UseOutlines )
             return true;
     }
     else if ( key == QLatin1String("DocumentScripts") && option.toString() == QLatin1String("JavaScript") )
     {
         QMutexLocker ml(userMutex());
         return pdfdoc->scripts();
     }
     else if ( key == QLatin1String("HasUnsupportedXfaForm") )
     {
         QMutexLocker ml(userMutex());
         return pdfdoc->formType() == Poppler::Document::XfaForm;
     }
     else if ( key == QLatin1String("FormCalculateOrder") )
     {
 #ifdef HAVE_POPPLER_0_53
         QMutexLocker ml(userMutex());
         return QVariant::fromValue<QVector<int>>(pdfdoc->formCalculateOrder());
 #endif
     }
     return QVariant();
 }
 
 bool PDFGenerator::reparseConfig()
 {
     if ( !pdfdoc )
         return false;
 
     bool somethingchanged = false;
     // load paper color
     QColor color = documentMetaData( PaperColorMetaData, true ).value< QColor >();
     // if paper color is changed we have to rebuild every visible pixmap in addition
     // to the outputDevice. it's the 'heaviest' case, other effect are just recoloring
     // over the page rendered on 'standard' white background.
     if ( color != pdfdoc->paperColor() )
     {
         userMutex()->lock();
         pdfdoc->setPaperColor(color);
         userMutex()->unlock();
         somethingchanged = true;
     }
     bool aaChanged = setDocumentRenderHints();
     somethingchanged = somethingchanged || aaChanged;
     return somethingchanged;
 }
 
 void PDFGenerator::addPages( KConfigDialog *dlg )
 {
 #ifdef HAVE_POPPLER_0_24
     Ui_PDFSettingsWidget pdfsw;
     QWidget* w = new QWidget(dlg);
     pdfsw.setupUi(w);
     dlg->addPage(w, PDFSettings::self(), i18n("PDF"), QStringLiteral("application-pdf"), i18n("PDF Backend Configuration") );
 #endif
 }
 
 bool PDFGenerator::setDocumentRenderHints()
 {
     bool changed = false;
     const Poppler::Document::RenderHints oldhints = pdfdoc->renderHints();
 #define SET_HINT(hintname, hintdefvalue, hintflag) \
 { \
     bool newhint = documentMetaData(hintname, hintdefvalue).toBool(); \
     if (newhint != oldhints.testFlag(hintflag)) \
     { \
         pdfdoc->setRenderHint(hintflag, newhint); \
         changed = true; \
     } \
 }
     SET_HINT(GraphicsAntialiasMetaData, true, Poppler::Document::Antialiasing)
     SET_HINT(TextAntialiasMetaData, true, Poppler::Document::TextAntialiasing)
     SET_HINT(TextHintingMetaData, false, Poppler::Document::TextHinting)
 #undef SET_HINT
 #ifdef HAVE_POPPLER_0_24
     // load thin line mode
     const int thinLineMode = PDFSettings::enhanceThinLines();
     const bool enableThinLineSolid = thinLineMode == PDFSettings::EnumEnhanceThinLines::Solid;
     const bool enableShapeLineSolid = thinLineMode == PDFSettings::EnumEnhanceThinLines::Shape;
     const bool thinLineSolidWasEnabled = (oldhints & Poppler::Document::ThinLineSolid) == Poppler::Document::ThinLineSolid;
     const bool thinLineShapeWasEnabled = (oldhints & Poppler::Document::ThinLineShape) == Poppler::Document::ThinLineShape;
     if (enableThinLineSolid != thinLineSolidWasEnabled) {
       pdfdoc->setRenderHint(Poppler::Document::ThinLineSolid, enableThinLineSolid);
       changed = true;
     }
     if (enableShapeLineSolid != thinLineShapeWasEnabled) {
       pdfdoc->setRenderHint(Poppler::Document::ThinLineShape, enableShapeLineSolid);
       changed = true;
     }
 #endif
     return changed;
 }
 
 Okular::ExportFormat::List PDFGenerator::exportFormats() const
 {
     static Okular::ExportFormat::List formats;
     if ( formats.isEmpty() ) {
         formats.append( Okular::ExportFormat::standardFormat( Okular::ExportFormat::PlainText ) );
     }
 
     return formats;
 }
 
 bool PDFGenerator::exportTo( const QString &fileName, const Okular::ExportFormat &format )
 {
     if ( format.mimeType().inherits( QStringLiteral( "text/plain" ) ) ) {
         QFile f( fileName );
         if ( !f.open( QIODevice::WriteOnly ) )
             return false;
 
         QTextStream ts( &f );
         int num = document()->pages();
         for ( int i = 0; i < num; ++i )
         {
             QString text;
             userMutex()->lock();
             Poppler::Page *pp = pdfdoc->page(i);
             if (pp)
             {
                 text = pp->text(QRect()).normalized(QString::NormalizationForm_KC);
             }
             userMutex()->unlock();
             ts << text;
             delete pp;
         }
         f.close();
 
         return true;
     }
 
     return false;
 }
 
 //END Generator inherited functions
 
 inline void append (Okular::TextPage* ktp,
     const QString &s, double l, double b, double r, double t)
 {
 //    kWarning(PDFDebug).nospace() << "text: " << s << " at (" << l << "," << t << ")x(" << r <<","<<b<<")";
     ktp->append(s, new Okular::NormalizedRect(l, t, r, b));
 }
 
 Okular::TextPage * PDFGenerator::abstractTextPage(const QList<Poppler::TextBox*> &text, double height, double width,int rot)
 {
     Q_UNUSED(rot);
     Okular::TextPage* ktp=new Okular::TextPage;
     Poppler::TextBox *next;
 #ifdef PDFGENERATOR_DEBUG
     qCDebug(OkularPdfDebug) << "getting text page in generator pdf - rotation:" << rot;
 #endif
     QString s;
     bool addChar;
     foreach (Poppler::TextBox *word, text)
     {
         const int qstringCharCount = word->text().length();
         next=word->nextWord();
         int textBoxChar = 0;
         for (int j = 0; j < qstringCharCount; j++)
         {
             const QChar c = word->text().at(j);
             if (c.isHighSurrogate())
             {
                 s = c;
                 addChar = false;
             }
             else if (c.isLowSurrogate())
             {
                 s += c;
                 addChar = true;
             }
             else
             {
                 s = c;
                 addChar = true;
             }
 
             if (addChar)
             {
                 QRectF charBBox = word->charBoundingBox(textBoxChar);
                 append(ktp, (j==qstringCharCount-1 && !next) ? (s + QLatin1Char('\n')) : s,
                     charBBox.left()/width,
                     charBBox.bottom()/height,
                     charBBox.right()/width,
                     charBBox.top()/height);
                 textBoxChar++;
             }
         }
 
         if ( word->hasSpaceAfter() && next )
         {
             // TODO Check with a document with vertical text
             // probably won't work and we will need to do comparisons
             // between wordBBox and nextWordBBox to see if they are
             // vertically or horizontally aligned
             QRectF wordBBox = word->boundingBox();
             QRectF nextWordBBox = next->boundingBox();
             append(ktp, QStringLiteral(" "),
                      wordBBox.right()/width,
                      wordBBox.bottom()/height,
                      nextWordBBox.left()/width,
                      wordBBox.top()/height);
         }
     }
     return ktp;
 }
 
 void PDFGenerator::addSynopsisChildren( QDomNode * parent, QDomNode * parentDestination )
 {
     // keep track of the current listViewItem
     QDomNode n = parent->firstChild();
     while( !n.isNull() )
     {
         // convert the node to an element (sure it is)
         QDomElement e = n.toElement();
 
         // The name is the same
         QDomElement item = docSyn.createElement( e.tagName() );
         parentDestination->appendChild(item);
 
         if (!e.attribute(QStringLiteral("ExternalFileName")).isNull()) item.setAttribute(QStringLiteral("ExternalFileName"), e.attribute(QStringLiteral("ExternalFileName")));
         if (!e.attribute(QStringLiteral("DestinationName")).isNull()) item.setAttribute(QStringLiteral("ViewportName"), e.attribute(QStringLiteral("DestinationName")));
         if (!e.attribute(QStringLiteral("Destination")).isNull())
         {
             Okular::DocumentViewport vp;
             fillViewportFromLinkDestination( vp, Poppler::LinkDestination(e.attribute(QStringLiteral("Destination"))) );
             item.setAttribute( QStringLiteral("Viewport"), vp.toString() );
         }
         if (!e.attribute(QStringLiteral("Open")).isNull()) item.setAttribute(QStringLiteral("Open"), e.attribute(QStringLiteral("Open")));
         if (!e.attribute(QStringLiteral("DestinationURI")).isNull()) item.setAttribute(QStringLiteral("URL"), e.attribute(QStringLiteral("DestinationURI")));
 
         // descend recursively and advance to the next node
         if ( e.hasChildNodes() ) addSynopsisChildren( &n, &    item );
         n = n.nextSibling();
     }
 }
 
 void PDFGenerator::addAnnotations( Poppler::Page * popplerPage, Okular::Page * page )
 {
 #ifdef HAVE_POPPLER_0_28
     QSet<Poppler::Annotation::SubType> subtypes;
     subtypes << Poppler::Annotation::AFileAttachment
         << Poppler::Annotation::ASound
         << Poppler::Annotation::AMovie
         << Poppler::Annotation::AWidget
         << Poppler::Annotation::AScreen
         << Poppler::Annotation::AText
         << Poppler::Annotation::ALine
         << Poppler::Annotation::AGeom
         << Poppler::Annotation::AHighlight
         << Poppler::Annotation::AInk
         << Poppler::Annotation::AStamp
         << Poppler::Annotation::ACaret;
 
     QList<Poppler::Annotation*> popplerAnnotations = popplerPage->annotations( subtypes );
 #else
     QList<Poppler::Annotation*> popplerAnnotations = popplerPage->annotations();
 #endif
 
     foreach(Poppler::Annotation *a, popplerAnnotations)
     {
         bool doDelete = true;
         Okular::Annotation * newann = createAnnotationFromPopplerAnnotation( a, &doDelete );
         if (newann)
         {
             page->addAnnotation(newann);
 
             if ( a->subType() == Poppler::Annotation::AScreen )
             {
                 Poppler::ScreenAnnotation *annotScreen = static_cast<Poppler::ScreenAnnotation*>( a );
                 Okular::ScreenAnnotation *screenAnnotation = static_cast<Okular::ScreenAnnotation*>( newann );
 
                 // The activation action
                 const Poppler::Link *actionLink = annotScreen->action();
                 if ( actionLink )
                     screenAnnotation->setAction( createLinkFromPopplerLink( actionLink ) );
 
                 // The additional actions
                 const Poppler::Link *pageOpeningLink = annotScreen->additionalAction( Poppler::Annotation::PageOpeningAction );
                 if ( pageOpeningLink )
                     screenAnnotation->setAdditionalAction( Okular::Annotation::PageOpening, createLinkFromPopplerLink( pageOpeningLink ) );
 
                 const Poppler::Link *pageClosingLink = annotScreen->additionalAction( Poppler::Annotation::PageClosingAction );
                 if ( pageClosingLink )
                     screenAnnotation->setAdditionalAction( Okular::Annotation::PageClosing, createLinkFromPopplerLink( pageClosingLink ) );
             }
 
             if ( a->subType() == Poppler::Annotation::AWidget )
             {
                 Poppler::WidgetAnnotation *annotWidget = static_cast<Poppler::WidgetAnnotation*>( a );
                 Okular::WidgetAnnotation *widgetAnnotation = static_cast<Okular::WidgetAnnotation*>( newann );
 
                 // The additional actions
                 const Poppler::Link *pageOpeningLink = annotWidget->additionalAction( Poppler::Annotation::PageOpeningAction );
                 if ( pageOpeningLink )
                     widgetAnnotation->setAdditionalAction( Okular::Annotation::PageOpening, createLinkFromPopplerLink( pageOpeningLink ) );
 
                 const Poppler::Link *pageClosingLink = annotWidget->additionalAction( Poppler::Annotation::PageClosingAction );
                 if ( pageClosingLink )
                     widgetAnnotation->setAdditionalAction( Okular::Annotation::PageClosing, createLinkFromPopplerLink( pageClosingLink ) );
             }
 
             if ( !doDelete )
                 annotationsHash.insert( newann, a );
         }
         if ( doDelete )
             delete a;
     }
 }
 
 void PDFGenerator::addTransition( Poppler::Page * pdfPage, Okular::Page * page )
 // called on opening when MUTEX is not used
 {
     Poppler::PageTransition *pdfTransition = pdfPage->transition();
     if ( !pdfTransition || pdfTransition->type() == Poppler::PageTransition::Replace )
         return;
 
     Okular::PageTransition *transition = new Okular::PageTransition();
     switch ( pdfTransition->type() ) {
         case Poppler::PageTransition::Replace:
             // won't get here, added to avoid warning
             break;
         case Poppler::PageTransition::Split:
             transition->setType( Okular::PageTransition::Split );
             break;
         case Poppler::PageTransition::Blinds:
             transition->setType( Okular::PageTransition::Blinds );
             break;
         case Poppler::PageTransition::Box:
             transition->setType( Okular::PageTransition::Box );
             break;
         case Poppler::PageTransition::Wipe:
             transition->setType( Okular::PageTransition::Wipe );
             break;
         case Poppler::PageTransition::Dissolve:
             transition->setType( Okular::PageTransition::Dissolve );
             break;
         case Poppler::PageTransition::Glitter:
             transition->setType( Okular::PageTransition::Glitter );
             break;
         case Poppler::PageTransition::Fly:
             transition->setType( Okular::PageTransition::Fly );
             break;
         case Poppler::PageTransition::Push:
             transition->setType( Okular::PageTransition::Push );
             break;
         case Poppler::PageTransition::Cover:
             transition->setType( Okular::PageTransition::Cover );
             break;
         case Poppler::PageTransition::Uncover:
             transition->setType( Okular::PageTransition::Uncover );
             break;
         case Poppler::PageTransition::Fade:
             transition->setType( Okular::PageTransition::Fade );
             break;
     }
 
 #ifdef HAVE_POPPLER_0_37
     transition->setDuration( pdfTransition->durationReal() );
 #else
     transition->setDuration( pdfTransition->duration() );
 #endif
 
     switch ( pdfTransition->alignment() ) {
         case Poppler::PageTransition::Horizontal:
             transition->setAlignment( Okular::PageTransition::Horizontal );
             break;
         case Poppler::PageTransition::Vertical:
             transition->setAlignment( Okular::PageTransition::Vertical );
             break;
     }
 
     switch ( pdfTransition->direction() ) {
         case Poppler::PageTransition::Inward:
             transition->setDirection( Okular::PageTransition::Inward );
             break;
         case Poppler::PageTransition::Outward:
             transition->setDirection( Okular::PageTransition::Outward );
             break;
     }
 
     transition->setAngle( pdfTransition->angle() );
     transition->setScale( pdfTransition->scale() );
     transition->setIsRectangular( pdfTransition->isRectangular() );
 
     page->setTransition( transition );
 }
 
 void PDFGenerator::addFormFields( Poppler::Page * popplerPage, Okular::Page * page )
 {
     QList<Poppler::FormField*> popplerFormFields = popplerPage->formFields();
     QLinkedList<Okular::FormField*> okularFormFields;
     foreach( Poppler::FormField *f, popplerFormFields )
     {
         Okular::FormField * of = 0;
         switch ( f->type() )
         {
             case Poppler::FormField::FormButton:
                 of = new PopplerFormFieldButton( static_cast<Poppler::FormFieldButton*>( f ) );
                 break;
             case Poppler::FormField::FormText:
                 of = new PopplerFormFieldText( static_cast<Poppler::FormFieldText*>( f ) );
                 break;
             case Poppler::FormField::FormChoice:
                 of = new PopplerFormFieldChoice( static_cast<Poppler::FormFieldChoice*>( f ) );
                 break;
             default: ;
         }
         if ( of )
             // form field created, good - it will take care of the Poppler::FormField
             okularFormFields.append( of );
         else
             // no form field available - delete the Poppler::FormField
             delete f;
     }
     if ( !okularFormFields.isEmpty() )
         page->setFormFields( okularFormFields );
 }
 
 PDFGenerator::PrintError PDFGenerator::printError() const
 {
     return lastPrintError;
 }
 
 QWidget* PDFGenerator::printConfigurationWidget() const
 {
     if ( !pdfOptionsPage )
     {
         const_cast<PDFGenerator*>(this)->pdfOptionsPage = new PDFOptionsPage();
     }
     return pdfOptionsPage;
 }
 
 bool PDFGenerator::supportsOption( SaveOption option ) const
 {
     switch ( option )
     {
         case SaveChanges:
         {
             return true;
         }
         default: ;
     }
     return false;
 }
 
 bool PDFGenerator::save( const QString &fileName, SaveOptions options, QString *errorText )
 {
     Q_UNUSED(errorText);
     Poppler::PDFConverter *pdfConv = pdfdoc->pdfConverter();
 
     pdfConv->setOutputFileName( fileName );
     if ( options & SaveChanges )
         pdfConv->setPDFOptions( pdfConv->pdfOptions() | Poppler::PDFConverter::WithChanges );
 
     QMutexLocker locker( userMutex() );
     bool success = pdfConv->convert();
     if (!success)
     {
         switch (pdfConv->lastError())
         {
             case Poppler::BaseConverter::NotSupportedInputFileError:
                 // This can only happen with Poppler before 0.22 which did not have qt5 version
             break;
 
             case Poppler::BaseConverter::NoError:
             case Poppler::BaseConverter::FileLockedError:
                 // we can't get here
             break;
 
             case Poppler::BaseConverter::OpenOutputError:
                 // the default text message is good for this case
             break;
         }
     }
     delete pdfConv;
     return success;
 }
 
 Okular::AnnotationProxy* PDFGenerator::annotationProxy() const
 {
     return annotProxy;
 }
 
 #include "generator_pdf.moc"
 
 Q_LOGGING_CATEGORY(OkularPdfDebug, "org.kde.okular.generators.pdf", QtWarningMsg)
 
 /* kate: replace-tabs on; indent-width 4; */
diff --git a/mobile/components/pageitem.cpp b/mobile/components/pageitem.cpp
index bb65e1d22..da165f1be 100644
--- a/mobile/components/pageitem.cpp
+++ b/mobile/components/pageitem.cpp
@@ -1,419 +1,418 @@
 /*
  *   Copyright 2012 by Marco Martin <mart@kde.org>
  *
  *   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 "pageitem.h"
 #include "documentitem.h"
 
 #include <QPainter>
 #include <QTimer>
 #include <QStyleOptionGraphicsItem>
-#include <QGuiApplication>
 
 #include <core/bookmarkmanager.h>
 #include <core/document.h>
 #include <core/generator.h>
 #include <core/page.h>
 
 #include "ui/pagepainter.h"
 #include "ui/priorities.h"
 #include "settings.h"
 
 #define REDRAW_TIMEOUT 250
 
 PageItem::PageItem(QQuickItem *parent)
     : QQuickPaintedItem(parent),
       Okular::View( QLatin1String( "PageView" ) ),
       m_page(0),
       m_smooth(false),
       m_intentionalDraw(false),
       m_bookmarked(false),
       m_isThumbnail(false)
 {
     setFlag(QQuickItem::ItemHasContents, true);
 
     m_viewPort.rePos.enabled = true;
 
     m_redrawTimer = new QTimer(this);
     m_redrawTimer->setInterval(REDRAW_TIMEOUT);
     m_redrawTimer->setSingleShot(true);
     connect(m_redrawTimer, &QTimer::timeout, this, &PageItem::delayedRedraw);
 }
 
 
 PageItem::~PageItem()
 {
 }
 
 void PageItem::setFlickable(QQuickItem *flickable)
 {
     if (m_flickable.data() == flickable) {
         return;
     }
 
     //check the object can act as a flickable
     if (!flickable->property("contentX").isValid() ||
         !flickable->property("contentY").isValid()) {
         return;
     }
 
     if (m_flickable) {
         disconnect(m_flickable.data(), 0, this, 0);
     }
 
     //check the object can act as a flickable
     if (!flickable->property("contentX").isValid() ||
         !flickable->property("contentY").isValid()) {
         m_flickable.clear();
         return;
     }
 
     m_flickable = flickable;
 
     if (flickable) {
         connect(flickable, SIGNAL(contentXChanged()), this, SLOT(contentXChanged()));
         connect(flickable, SIGNAL(contentYChanged()), this, SLOT(contentYChanged()));
     }
 
     emit flickableChanged();
 }
 
 QQuickItem *PageItem::flickable() const
 {
     return m_flickable.data();
 }
 
 DocumentItem *PageItem::document() const
 {
     return m_documentItem.data();
 }
 
 void PageItem::setDocument(DocumentItem *doc)
 {
     if (doc == m_documentItem.data() || !doc) {
         return;
     }
 
     m_page = 0;
     disconnect(doc, 0, this, 0);
     m_documentItem = doc;
     Observer *observer = m_isThumbnail ? m_documentItem.data()->thumbnailObserver() : m_documentItem.data()->pageviewObserver();
     connect(observer, &Observer::pageChanged, this, &PageItem::pageHasChanged);
     connect(doc->document()->bookmarkManager(), &Okular::BookmarkManager::bookmarksChanged,
             this, &PageItem::checkBookmarksChanged);
     setPageNumber(0);
     emit documentChanged();
     m_redrawTimer->start();
 
     connect(doc, &DocumentItem::pathChanged, this, &PageItem::documentPathChanged);
 }
 
 int PageItem::pageNumber() const
 {
     return m_viewPort.pageNumber;
 }
 
 void PageItem::setPageNumber(int number)
 {
     if ((m_page && m_viewPort.pageNumber == number) ||
         !m_documentItem ||
         !m_documentItem.data()->isOpened() ||
         number < 0 ||
         (uint)number >= m_documentItem.data()->document()->pages()) {
         return;
     }
 
     m_viewPort.pageNumber = number;
     m_page = m_documentItem.data()->document()->page(number);
 
     emit pageNumberChanged();
     emit implicitWidthChanged();
     emit implicitHeightChanged();
     checkBookmarksChanged();
     m_redrawTimer->start();
 }
 
 int PageItem::implicitWidth() const
 {
     if (m_page) {
         return m_page->width();
     }
     return 0;
 }
 
 int PageItem::implicitHeight() const
 {
     if (m_page) {
         return m_page->height();
     }
     return 0;
 }
 
 void PageItem::setSmooth(const bool smooth)
 {
     if (smooth == m_smooth) {
         return;
     }
     m_smooth = smooth;
     update();
 }
 
 bool PageItem::smooth() const
 {
     return m_smooth;
 }
 
 bool PageItem::isBookmarked()
 {
     return m_bookmarked;
 }
 
 void PageItem::setBookmarked(bool bookmarked)
 {
     if (!m_documentItem) {
         return;
     }
 
     if (bookmarked == m_bookmarked) {
         return;
     }
 
     if (bookmarked) {
         m_documentItem.data()->document()->bookmarkManager()->addBookmark(m_viewPort);
     } else {
         m_documentItem.data()->document()->bookmarkManager()->removeBookmark(m_viewPort.pageNumber);
     }
     m_bookmarked = bookmarked;
     emit bookmarkedChanged();
 }
 
 QStringList PageItem::bookmarks() const
 {
     QStringList list;
     foreach(const KBookmark &bookmark, m_documentItem.data()->document()->bookmarkManager()->bookmarks(m_viewPort.pageNumber)) {
         list << bookmark.url().toString();
     }
     return list;
 }
 
 void PageItem::goToBookmark(const QString &bookmark)
 {
     Okular::DocumentViewport viewPort(QUrl::fromUserInput(bookmark).fragment(QUrl::FullyDecoded));
     setPageNumber(viewPort.pageNumber);
 
     //Are we in a flickable?
     if (m_flickable) {
         //normalizedX is a proportion, so contentX will be the difference between document and viewport times normalizedX
         m_flickable.data()->setProperty("contentX", qMax((qreal)0, width() - m_flickable.data()->width()) * viewPort.rePos.normalizedX);
 
         m_flickable.data()->setProperty("contentY", qMax((qreal)0, height() - m_flickable.data()->height()) * viewPort.rePos.normalizedY);
     }
 }
 
 QPointF PageItem::bookmarkPosition(const QString &bookmark) const
 {
     Okular::DocumentViewport viewPort(QUrl::fromUserInput(bookmark).fragment(QUrl::FullyDecoded));
 
     if (viewPort.pageNumber != m_viewPort.pageNumber) {
         return QPointF(-1, -1);
     }
 
     return QPointF(qMax((qreal)0, width() - m_flickable.data()->width()) * viewPort.rePos.normalizedX,
                    qMax((qreal)0, height() - m_flickable.data()->height()) * viewPort.rePos.normalizedY);
 }
 
 void PageItem::setBookmarkAtPos(qreal x, qreal y)
 {
     Okular::DocumentViewport viewPort(m_viewPort);
     viewPort.rePos.normalizedX = x;
     viewPort.rePos.normalizedY = y;
 
     m_documentItem.data()->document()->bookmarkManager()->addBookmark(viewPort);
 
     if (!m_bookmarked) {
         m_bookmarked = true;
         emit bookmarkedChanged();
     }
 
     emit bookmarksChanged();
 }
 
 void PageItem::removeBookmarkAtPos(qreal x, qreal y)
 {
     Okular::DocumentViewport viewPort(m_viewPort);
     viewPort.rePos.enabled = true;
     viewPort.rePos.normalizedX = x;
     viewPort.rePos.normalizedY = y;
 
     m_documentItem.data()->document()->bookmarkManager()->addBookmark(viewPort);
 
     if (m_bookmarked && m_documentItem.data()->document()->bookmarkManager()->bookmarks(m_viewPort.pageNumber).count() == 0) {
         m_bookmarked = false;
         emit bookmarkedChanged();
     }
 
     emit bookmarksChanged();
 }
 
 void PageItem::removeBookmark(const QString &bookmark)
 {
     m_documentItem.data()->document()->bookmarkManager()->removeBookmark(bookmark);
     emit bookmarksChanged();
 }
 
 //Reimplemented
 void PageItem::geometryChanged(const QRectF &newGeometry,
                                const QRectF &oldGeometry)
 {
     setContentsSize(newGeometry.size().toSize());
 
     if (newGeometry.size().isEmpty()) {
         return;
     }
 
     if (newGeometry.size() != oldGeometry.size()) {
         m_redrawTimer->start();
     }
 
     QQuickItem::geometryChanged(newGeometry, oldGeometry);
     //Why aren't they automatically emuitted?
     emit widthChanged();
     emit heightChanged();
 }
 
 void PageItem::paint(QPainter *painter)
 {
     if (!m_documentItem || !m_page) {
         return;
     }
 
     const bool setAA = m_smooth && !(painter->renderHints() & QPainter::Antialiasing);
     if (setAA) {
         painter->save();
         painter->setRenderHint(QPainter::Antialiasing, true);
     }
 
     Observer *observer = m_isThumbnail ? m_documentItem.data()->thumbnailObserver() : m_documentItem.data()->pageviewObserver();
     const int priority = m_isThumbnail ? THUMBNAILS_PRIO : PAGEVIEW_PRIO;
 
     if (m_intentionalDraw) {
         QLinkedList<Okular::PixmapRequest *> requestedPixmaps;
-        requestedPixmaps.push_back(new Okular::PixmapRequest(observer, m_viewPort.pageNumber, width(), height(), qApp->devicePixelRatio(), priority, Okular::PixmapRequest::Asynchronous));
+        requestedPixmaps.push_back(new Okular::PixmapRequest(observer, m_viewPort.pageNumber, width(), height(), priority, Okular::PixmapRequest::Asynchronous));
         const Okular::Document::PixmapRequestFlag prf = m_isThumbnail ? Okular::Document::NoOption : Okular::Document::RemoveAllPrevious;
         m_documentItem.data()->document()->requestPixmaps(requestedPixmaps, prf);
         m_intentionalDraw = false;
     }
     const int flags = PagePainter::Accessibility | PagePainter::Highlights | PagePainter::Annotations;
     // Simply using the limits as described by contentsSize will, at times, result in the page painter
     // attempting to write outside the data area, unsurprisingly resulting in a crash.
     QRect limits(QPoint(0, 0), contentsSize());
     if(limits.width() > width())
         limits.setWidth(width());
     if(limits.height() > height())
         limits.setHeight(height());
     PagePainter::paintPageOnPainter(painter, m_page, observer, flags, width(), height(), limits);
 
     if (setAA) {
         painter->restore();
     }
 }
 
 //Protected slots
 void PageItem::delayedRedraw()
 {
     if (m_documentItem && m_page) {
         m_intentionalDraw = true;
         update();
     }
 }
 
 void PageItem::pageHasChanged(int page, int flags)
 {
     if (m_viewPort.pageNumber == page) {
         if (flags == 32) {
             // skip bounding box updates
             //kDebug() << "32" << m_page->boundingBox();
         } else if (flags == Okular::DocumentObserver::Pixmap) {
             // if pixmaps have updated, just repaint .. don't bother updating pixmaps AGAIN
             update();
         } else {
             m_redrawTimer->start();
         }
     }
 }
 
 void PageItem::checkBookmarksChanged()
 {
     if (!m_documentItem) {
         return;
     }
 
     bool newBookmarked = m_documentItem.data()->document()->bookmarkManager()->isBookmarked(m_viewPort.pageNumber);
     if (m_bookmarked != newBookmarked) {
         m_bookmarked = newBookmarked;
         emit bookmarkedChanged();
     }
 
     //TODO: check the page
     emit bookmarksChanged();
 }
 
 void PageItem::contentXChanged()
 {
     if (!m_flickable || !m_flickable.data()->property("contentX").isValid()) {
         return;
     }
 
     m_viewPort.rePos.normalizedX = m_flickable.data()->property("contentX").toReal() / (width() - m_flickable.data()->width());
 }
 
 void PageItem::contentYChanged()
 {
     if (!m_flickable || !m_flickable.data()->property("contentY").isValid()) {
         return;
     }
 
     m_viewPort.rePos.normalizedY = m_flickable.data()->property("contentY").toReal() / (height() - m_flickable.data()->height());
 }
 
 void PageItem::documentPathChanged()
 {
     m_page = 0;
     setPageNumber(0);
 
     m_redrawTimer->start();
 }
 
 
 void PageItem::setIsThumbnail(bool thumbnail)
 {
     if (thumbnail == m_isThumbnail) {
         return;
     }
 
     m_isThumbnail = thumbnail;
 
     if (thumbnail) {
         m_smooth = false;
     }
 
     /*
     m_redrawTimer->setInterval(thumbnail ? 0 : REDRAW_TIMEOUT);
     m_redrawTimer->setSingleShot(true);
     */
 }
diff --git a/ui/magnifierview.cpp b/ui/magnifierview.cpp
index 82530673a..78af53574 100644
--- a/ui/magnifierview.cpp
+++ b/ui/magnifierview.cpp
@@ -1,193 +1,193 @@
 /*
  * 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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "magnifierview.h"
 
 #include <QPainter>
 
 #include "core/document.h"
 #include "core/generator.h"
 #include "pagepainter.h"
 #include "priorities.h"
 
 static const int SCALE = 10;
 
 MagnifierView::MagnifierView(Okular::Document* document, QWidget* parent)
   : QWidget(parent)
   , m_document(document)
   , m_page(0)
 {
   document->addObserver(this);
 }
 
 MagnifierView::~MagnifierView()
 {
   m_document->removeObserver(this);
 }
 
 void MagnifierView::notifySetup(const QVector< Okular::Page* >& pages, int setupFlags)
 {
   if (!(setupFlags & Okular::DocumentObserver::DocumentChanged)) {
     return;
   }
 
   m_pages = pages;
   m_page = 0;
   m_current = -1;
 }
 
 void MagnifierView::notifyPageChanged(int page, int flags)
 {
   Q_UNUSED(page);
   Q_UNUSED(flags);
 
   if (isVisible()) {
     update();
   }
 }
 
 bool MagnifierView::canUnloadPixmap(int page) const
 {
   return (page != m_current);
 }
 
 void MagnifierView::notifyCurrentPageChanged(int previous, int current)
 {
   Q_UNUSED(previous);
 
   if (current != m_current) {
     m_current = current;
     m_page = m_pages[current];
 
     if (isVisible()) {
       requestPixmap();
       update();
     }
   }
 }
 
 void MagnifierView::updateView( const Okular::NormalizedPoint& p, const Okular::Page *page )
 {
   m_viewpoint = p;
 
   if (page != m_page) // ok, we are screwed
   {
     m_page = page;
     m_current = page->number();
   }
 
   if (isVisible()) {
     requestPixmap();
     update();
   }
 }
 
 void MagnifierView::paintEvent(QPaintEvent* e)
 {
   Q_UNUSED(e);
 
   QPainter p(this);
 
   if (m_page)
   {
     QRect where = QRect(0, 0, width(), height());
     PagePainter::paintCroppedPageOnPainter(&p, m_page, this, 0, m_page->width() * SCALE, m_page->height() * SCALE, where, normalizedView(), NULL);
   }
 
   drawTicks(&p);
 }
 
 void MagnifierView::move( int x, int y)
 {
   QWidget::move( x, y );
   requestPixmap();
 }
 
 void MagnifierView::requestPixmap()
 {
   const int full_width = m_page->width() * SCALE;
   const int full_height = m_page->height() * SCALE;
 
   Okular::NormalizedRect nrect = normalizedView();
 
   if (m_page && !m_page->hasPixmap( this, full_width, full_height, nrect ))
   {
     QLinkedList< Okular::PixmapRequest * > requestedPixmaps;
 
-    Okular::PixmapRequest *p = new Okular::PixmapRequest( this, m_current, full_width, full_height, devicePixelRatioF(), PAGEVIEW_PRIO, Okular::PixmapRequest::Asynchronous );
+    Okular::PixmapRequest *p = new Okular::PixmapRequest( this, m_current, full_width, full_height, PAGEVIEW_PRIO, Okular::PixmapRequest::Asynchronous );
 
     if ( m_page->hasTilesManager( this ) ) {
       p->setTile( true );
     }
 
     // request a little bit bigger rectangle then currently viewed, but not the full scale page
     const double rect_width = (nrect.right - nrect.left) * 0.5,
                  rect_height = (nrect.bottom - nrect.top) * 0.5;
 
     const double top = qMax(nrect.top - rect_height, 0.0);
     const double bottom = qMin(nrect.bottom + rect_height, 1.0);
     const double left = qMax(nrect.left - rect_width, 0.0);
     const double right = qMin(nrect.right + rect_width, 1.0);
 
     p->setNormalizedRect( Okular::NormalizedRect(left, top, right, bottom) );
     requestedPixmaps.push_back( p );
 
     m_document->requestPixmaps( requestedPixmaps );
   }
 }
 
 Okular::NormalizedRect MagnifierView::normalizedView() const
 {
   double h = (double)height() / (SCALE * m_page->height() * 2);
   double w = (double)width() / (SCALE * m_page->width() * 2);
   return Okular::NormalizedRect(m_viewpoint.x - w, m_viewpoint.y - h, m_viewpoint.x + w, m_viewpoint.y + h);
 }
 
 void MagnifierView::drawTicks( QPainter *p )
 {
   p->save();
 
   p->setPen(QPen(Qt::black, 0));
   // the cross
   p->drawLine(width() / 2, 0, width() / 2, height() - 1);
   p->drawLine(0, height() / 2, width() - 1, height() / 2);
 
   // the borders
   p->drawLine(0, 0, width() - 1, 0);
   p->drawLine(width() - 1, 0,  width() - 1, height() - 1);
   p->drawLine(0, height() - 1, width() - 1, height() - 1);
   p->drawLine(0, height() - 1, 0, 0);
 
   // ticks
   // TODO posibility to switch units (pt, mm, cc, in, printing dots)
   float ps = (float)SCALE * 5;// how much pixels in widget is one pixel in document * how often
   int tw = 10; // tick size in pixels
 
   for ( float x = 0; x < width(); x += ps )
   {
     p->drawLine(x, 1, x, tw);
     p->drawLine(x, height() - 1, x, height() - tw - 1);
     p->drawLine(1, x, tw, x);
     p->drawLine(width() - 1, x, width() - tw - 1, x);
   }
 
   p->restore();
 }
 
 #include "moc_magnifierview.cpp"
diff --git a/ui/pagepainter.cpp b/ui/pagepainter.cpp
index a4ab918d1..9918540d5 100644
--- a/ui/pagepainter.cpp
+++ b/ui/pagepainter.cpp
@@ -1,1073 +1,1061 @@
 /***************************************************************************
  *   Copyright (C) 2005 by Enrico Ros <eros.kde@email.it>                  *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "pagepainter.h"
 
 // qt / kde includes
 #include <qrect.h>
 #include <qpainter.h>
 #include <qpalette.h>
 #include <qpixmap.h>
 #include <qvarlengtharray.h>
 #include <kiconloader.h>
 #include <QtCore/QDebug>
 #include <QApplication>
 #include <QIcon>
 
 // system includes
 #include <math.h>
 
 // local includes
 #include "core/area.h"
 #include "core/page.h"
 #include "core/page_p.h"
 #include "core/annotations.h"
 #include "core/utils.h"
 #include "guiutils.h"
 #include "settings.h"
 #include "core/observer.h"
 #include "core/tile.h"
 #include "settings_core.h"
 #include "ui/debug_ui.h"
 
 Q_GLOBAL_STATIC_WITH_ARGS( QPixmap, busyPixmap, ( KIconLoader::global()->loadIcon(QLatin1String("okular"), KIconLoader::NoGroup, IconSize(KIconLoader::Desktop), KIconLoader::DefaultState, QStringList(), 0, true) ) )
 
 #define TEXTANNOTATION_ICONSIZE 24
 
 inline QPen buildPen( const Okular::Annotation *ann, double width, const QColor &color )
 {
     QPen p(
         QBrush( color ),
         width,
         ann->style().lineStyle() == Okular::Annotation::Dashed ? Qt::DashLine : Qt::SolidLine,
         Qt::SquareCap,
         Qt::MiterJoin
     );
     return p;
 }
 
 void PagePainter::paintPageOnPainter( QPainter * destPainter, const Okular::Page * page,
     Okular::DocumentObserver *observer, int flags, int scaledWidth, int scaledHeight, const QRect &limits )
 {
         paintCroppedPageOnPainter( destPainter, page, observer, flags, scaledWidth, scaledHeight, limits,
                                    Okular::NormalizedRect( 0, 0, 1, 1 ), 0 );
 }
 
 void PagePainter::paintCroppedPageOnPainter( QPainter * destPainter, const Okular::Page * page,
     Okular::DocumentObserver *observer, int flags, int scaledWidth, int scaledHeight, const QRect &limits,
     const Okular::NormalizedRect &crop, Okular::NormalizedPoint *viewPortPoint )
 {
     qreal dpr = destPainter->device()->devicePixelRatioF();
 
-    qDebug() << "PagePainter dpr" << dpr;
-    
     /* Calculate the cropped geometry of the page */
     QRect scaledCrop = crop.geometry( scaledWidth, scaledHeight );
     const QRect dScaledCrop(QRectF(scaledCrop.x() * dpr, scaledCrop.y() * dpr, scaledCrop.width() * dpr, scaledCrop.height() * dpr).toAlignedRect());
 
     int croppedWidth = scaledCrop.width();
     int croppedHeight = scaledCrop.height();
 
     int dScaledWidth = ceil(scaledWidth * dpr);
     int dScaledHeight = ceil(scaledHeight * dpr);
     const QRect dLimits(QRectF(limits.x() * dpr, limits.y() * dpr, limits.width() * dpr, limits.height() * dpr).toAlignedRect());
 
-    qDebug() << "PagePainter dScaledWidth" << dScaledWidth << "dScaledHeight" << dScaledHeight;
-    qDebug() << "PagePainter dLimits" << dLimits;
-    
     QColor paperColor = Qt::white;
     QColor backgroundColor = paperColor;
     if ( Okular::SettingsCore::changeColors() )
     {
         switch ( Okular::SettingsCore::renderMode() )
         {
             case Okular::SettingsCore::EnumRenderMode::Inverted:
                 backgroundColor = Qt::black;
                 break;
             case Okular::SettingsCore::EnumRenderMode::Paper:
                 paperColor = Okular::SettingsCore::paperColor();
                 backgroundColor = paperColor;
                 break;
             case Okular::SettingsCore::EnumRenderMode::Recolor:
                 backgroundColor = Okular::Settings::recolorBackground();
                 break;
             default: ;
         }
     }
     destPainter->fillRect( limits, backgroundColor );
 
     const bool hasTilesManager = page->hasTilesManager( observer );
     QPixmap pixmap;
 
     if ( !hasTilesManager )
     {
         /** 1 - RETRIEVE THE 'PAGE+ID' PIXMAP OR A SIMILAR 'PAGE' ONE **/
         const QPixmap *p = 0;
-        
-        p = page->_o_nearestPixmap( observer, dScaledWidth, dScaledHeight, dpr );
+
+        p = page->_o_nearestPixmap( observer, dScaledWidth, dScaledHeight );
         if ( p != NULL ) {
-            qDebug() << "PagePainter PIXMAP IS NOT NULL";
             pixmap = p->copy();
             pixmap.setDevicePixelRatio( qApp->devicePixelRatio() );
-        } else {
-            qDebug() << "PagePainter PIXMAP IS NULL";
         }
-        
-        //pixmap.setDevicePixelRatio( qApp->devicePixelRatio() );
 
         /** 1B - IF NO PIXMAP, DRAW EMPTY PAGE **/
         double pixmapRescaleRatio = !pixmap.isNull() ? dScaledWidth / (double)pixmap.width() : -1;
         long pixmapPixels = !pixmap.isNull() ? (long)pixmap.width() * (long)pixmap.height() : 0;
         if ( pixmap.isNull() || pixmapRescaleRatio > 20.0 || pixmapRescaleRatio < 0.25 ||
              (dScaledWidth > pixmap.width() && pixmapPixels > 60000000L) )
         {
             // draw something on the blank page: the okular icon or a cross (as a fallback)
             if ( !busyPixmap()->isNull() )
             {
                 busyPixmap->setDevicePixelRatio(dpr);
                 destPainter->drawPixmap( QPoint( 10, 10 ), *busyPixmap() );
             }
             else
             {
                 destPainter->setPen( Qt::gray );
                 destPainter->drawLine( 0, 0, croppedWidth-1, croppedHeight-1 );
                 destPainter->drawLine( 0, croppedHeight-1, croppedWidth-1, 0 );
             }
-            
-            qDebug() << "PagePainter !hasTilesManager";
             return;
         }
     }
 
     /** 2 - FIND OUT WHAT TO PAINT (Flags + Configuration + Presence) **/
     bool canDrawHighlights = (flags & Highlights) && !page->m_highlights.isEmpty();
     bool canDrawTextSelection = (flags & TextSelection) && page->textSelection();
     bool canDrawAnnotations = (flags & Annotations) && !page->m_annotations.isEmpty();
     bool enhanceLinks = (flags & EnhanceLinks) && Okular::Settings::highlightLinks();
     bool enhanceImages = (flags & EnhanceImages) && Okular::Settings::highlightImages();
 
     // vectors containing objects to draw
     // make this a qcolor, rect map, since we don't need
     // to know s_id here! we are only drawing this right?
     QList< QPair<QColor, Okular::NormalizedRect> > * bufferedHighlights = 0;
     QList< Okular::Annotation * > * bufferedAnnotations = 0;
     QList< Okular::Annotation * > * unbufferedAnnotations = 0;
     Okular::Annotation *boundingRectOnlyAnn = 0; // Paint the bounding rect of this annotation
     // fill up lists with visible annotation/highlight objects/text selections
     if ( canDrawHighlights || canDrawTextSelection || canDrawAnnotations )
     {
         // precalc normalized 'limits rect' for intersection
         double nXMin = ( (double)limits.left() / dScaledWidth ) + crop.left,
                nXMax = ( (double)limits.right() / dScaledWidth )  + crop.left,
                nYMin = ( (double)limits.top() / dScaledHeight ) + crop.top,
                nYMax = ( (double)limits.bottom() / dScaledHeight ) + crop.top;
         // append all highlights inside limits to their list
         if ( canDrawHighlights )
         {
             if ( !bufferedHighlights )
                  bufferedHighlights = new QList< QPair<QColor, Okular::NormalizedRect> >();
 /*            else
             {*/
                 
                 Okular::NormalizedRect* limitRect = new Okular::NormalizedRect(nXMin, nYMin, nXMax, nYMax );
                 QLinkedList< Okular::HighlightAreaRect * >::const_iterator h2It = page->m_highlights.constBegin(), hEnd = page->m_highlights.constEnd();
                 Okular::HighlightAreaRect::const_iterator hIt;
                 for ( ; h2It != hEnd; ++h2It )
                     for (hIt=(*h2It)->constBegin(); hIt!=(*h2It)->constEnd(); ++hIt)
                     {
                         if ((*hIt).intersects(limitRect))
                             bufferedHighlights->append( qMakePair((*h2It)->color,*hIt) );
                     }
                 delete limitRect;
             //}
         }
         if ( canDrawTextSelection )
         {
             if ( !bufferedHighlights )
                  bufferedHighlights = new QList< QPair<QColor, Okular::NormalizedRect>  >();
 /*            else
             {*/
                 Okular::NormalizedRect* limitRect = new Okular::NormalizedRect(nXMin, nYMin, nXMax, nYMax );
                 const Okular::RegularAreaRect *textSelection = page->textSelection();
                 Okular::HighlightAreaRect::const_iterator hIt = textSelection->constBegin(), hEnd = textSelection->constEnd();
                 for ( ; hIt != hEnd; ++hIt )
                 {
                     if ( (*hIt).intersects( limitRect ) )
                         bufferedHighlights->append( qMakePair( page->textSelectionColor(), *hIt ) );
                 }
                 delete limitRect;
             //}
         }
         // append annotations inside limits to the un/buffered list
         if ( canDrawAnnotations )
         {
             QLinkedList< Okular::Annotation * >::const_iterator aIt = page->m_annotations.constBegin(), aEnd = page->m_annotations.constEnd();
             for ( ; aIt != aEnd; ++aIt )
             {
                 Okular::Annotation * ann = *aIt;
                 int flags = ann->flags();
 
                 if ( flags & Okular::Annotation::Hidden )
                     continue;
 
                 if ( flags & Okular::Annotation::ExternallyDrawn )
                 {
                     // ExternallyDrawn annots are never rendered by PagePainter.
                     // Just paint the boundingRect if the annot is moved or resized.
                     if ( flags & (Okular::Annotation::BeingMoved | Okular::Annotation::BeingResized) )
                     {
                         boundingRectOnlyAnn = ann;
                     }
                     continue;
                 }
 
                 bool intersects = ann->transformedBoundingRectangle().intersects( nXMin, nYMin, nXMax, nYMax );
                 if ( ann->subType() == Okular::Annotation::AText )
                 {
                     Okular::TextAnnotation * ta = static_cast< Okular::TextAnnotation * >( ann );
                     if ( ta->textType() == Okular::TextAnnotation::Linked )
                     {
                         Okular::NormalizedRect iconrect( ann->transformedBoundingRectangle().left,
                                                          ann->transformedBoundingRectangle().top,
                                                          ann->transformedBoundingRectangle().left + TEXTANNOTATION_ICONSIZE / page->width(),
                                                          ann->transformedBoundingRectangle().top + TEXTANNOTATION_ICONSIZE / page->height() );
                         intersects = iconrect.intersects( nXMin, nYMin, nXMax, nYMax );
                     }
                 }
                 if ( intersects )
                 {
                     Okular::Annotation::SubType type = ann->subType();
                     if ( type == Okular::Annotation::ALine || type == Okular::Annotation::AHighlight ||
                          type == Okular::Annotation::AInk  /*|| (type == Annotation::AGeom && ann->style().opacity() < 0.99)*/ )
                     {
                         if ( !bufferedAnnotations )
                             bufferedAnnotations = new QList< Okular::Annotation * >();
                         bufferedAnnotations->append( ann );
                     }
                     else
                     {
                         if ( !unbufferedAnnotations )
                             unbufferedAnnotations = new QList< Okular::Annotation * >();
                         unbufferedAnnotations->append( ann );
                     }
                 }
             }
         }
         // end of intersections checking
     }
 
     /** 3 - ENABLE BACKBUFFERING IF DIRECT IMAGE MANIPULATION IS NEEDED **/
     bool bufferAccessibility = (flags & Accessibility) && Okular::SettingsCore::changeColors() && (Okular::SettingsCore::renderMode() != Okular::SettingsCore::EnumRenderMode::Paper);
     bool useBackBuffer = bufferAccessibility || bufferedHighlights || bufferedAnnotations || viewPortPoint;
     QPixmap * backPixmap = 0;
     QPainter * mixedPainter = 0;
     QRect limitsInPixmap = limits.translated( scaledCrop.topLeft() );
     QRect dLimitsInPixmap = dLimits.translated( dScaledCrop.topLeft() );
 
         // limits within full (scaled but uncropped) pixmap
 
     /** 4A -- REGULAR FLOW. PAINT PIXMAP NORMAL OR RESCALED USING GIVEN QPAINTER **/
     /* when zoomed in */
     if ( !useBackBuffer )
     {
         if ( hasTilesManager )
         {
             const Okular::NormalizedRect normalizedLimits( limitsInPixmap, scaledWidth, scaledHeight );
             const QList<Okular::Tile> tiles = page->tilesAt( observer, normalizedLimits );
             QList<Okular::Tile>::const_iterator tIt = tiles.constBegin(), tEnd = tiles.constEnd();
             while ( tIt != tEnd )
             {
                 const Okular::Tile &tile = *tIt;
                 QRect tileRect = tile.rect().geometry( scaledWidth, scaledHeight ).translated( -scaledCrop.topLeft() );
                 QRect dTileRect = QRectF(tileRect.x() * dpr, tileRect.y() * dpr, tileRect.width() * dpr, tileRect.height() * dpr).toAlignedRect();
                 QRect limitsInTile = limits & tileRect;
                 QRectF dLimitsInTile = dLimits & dTileRect;
 
                 if ( !limitsInTile.isEmpty() )
                 {
                     QPixmap tilePixmap = tile.pixmap()->copy();
                     tilePixmap.setDevicePixelRatio( qApp->devicePixelRatio() );
-                    
+
                     if ( tilePixmap.width() == dTileRect.width() && tilePixmap.height() == dTileRect.height() ) {
                         destPainter->drawPixmap( limitsInTile.topLeft(), tilePixmap,
                                 dLimitsInTile.translated( -dTileRect.topLeft() ) );
                         qCWarning(OkularUiDebug) << "PagePainter: 4AT1";
                     } else {
                         destPainter->drawPixmap( tileRect, tilePixmap);
                         qCWarning(OkularUiDebug) << "PagePainter: 4AT2";
                     }
                 }
                 tIt++;
             }
         }
         else
         {
             QPixmap scaledCroppedPixmap = pixmap.scaled(dScaledWidth, dScaledHeight).copy(dLimitsInPixmap);
             destPainter->drawPixmap( limits.topLeft(), scaledCroppedPixmap, QRectF(0, 0, dLimits.width(),dLimits.height()));
             qCWarning(OkularUiDebug) << "PagePainter: 4AN";
         }
 
         // 4A.2. active painter is the one passed to this method
         mixedPainter = destPainter;
     }
     /** 4B -- BUFFERED FLOW. IMAGE PAINTING + OPERATIONS. QPAINTER OVER PIXMAP  **/
     else
     {
         // the image over which we are going to draw
         QImage backImage = QImage( dLimits.width(), dLimits.height(), QImage::Format_ARGB32_Premultiplied );
         backImage.setDevicePixelRatio(dpr);
         backImage.fill( paperColor );
         QPainter p( &backImage );
 
         bool has_alpha;
         if ( !pixmap.isNull() )
             has_alpha = pixmap.hasAlpha();
         else
             has_alpha = true;
 
         if ( hasTilesManager )
         {
             const Okular::NormalizedRect normalizedLimits( limitsInPixmap, scaledWidth, scaledHeight );
             const QList<Okular::Tile> tiles = page->tilesAt( observer, normalizedLimits );
             QList<Okular::Tile>::const_iterator tIt = tiles.constBegin(), tEnd = tiles.constEnd();
             while ( tIt != tEnd )
             {
                 const Okular::Tile &tile = *tIt;
                 QRect tileRect = tile.rect().geometry( scaledWidth, scaledHeight ).translated( -scaledCrop.topLeft() );
                 QRect dTileRect(QRectF(tileRect.x() * dpr, tileRect.y() * dpr, tileRect.width() * dpr, tileRect.height() * dpr).toAlignedRect());
                 QRect limitsInTile = limits & tileRect;
                 QRect dLimitsInTile = dLimits & dTileRect;
 
                 if ( !limitsInTile.isEmpty() )
                 {
                     QPixmap tilePixmap = tile.pixmap()->copy();
                     tilePixmap.setDevicePixelRatio( qApp->devicePixelRatio() );
-                    
+
                     if ( !tilePixmap.hasAlpha() )
                         has_alpha = false;
 
                     if ( tilePixmap.width() == dTileRect.width() && tilePixmap.height() == dTileRect.height() )
                     {
                         qCWarning(OkularUiDebug) << "PagePainter: 4BT1";
                         p.drawPixmap( limitsInTile.translated( -limits.topLeft() ).topLeft(), tilePixmap,
                                 dLimitsInTile.translated( -dTileRect.topLeft() ) );
                     }
                     else
                     {
                         qCWarning(OkularUiDebug) << "PagePainter: 4BT2";
                         double xScale = tilePixmap.width() / (double)dTileRect.width();
                         double yScale = tilePixmap.height() / (double)dTileRect.height();
                         QTransform transform( xScale, 0, 0, yScale, 0, 0 );
                         p.drawPixmap( limitsInTile.translated( -limits.topLeft() ), tilePixmap,
                                 transform.mapRect( dLimitsInTile ).translated( -transform.mapRect( dTileRect ).topLeft() ) );
                         //tilePixmap.save("/tmp/pix.png");
                         qCWarning(OkularUiDebug) << "PagePainter: 4BT2 DONE";
                     }
                 }
                 ++tIt;
             }
         }
         else
         {
             // 4B.1. draw the page pixmap: normal or scaled
             QString r = QString::number(qrand());
             qDebug() << "PagePainter: 4BN: " << r;
             QPixmap scaledCroppedPixmap = pixmap.scaled(dScaledWidth, dScaledHeight).copy(dLimitsInPixmap);
             scaledCroppedPixmap.setDevicePixelRatio(dpr);
             //scaledCroppedPixmap.save("/tmp/paint/p_" + QString::number(page->number()) + "_" + r + "_4bn.png");
             p.drawPixmap( 0, 0, scaledCroppedPixmap );
         }
 
         p.end();
 
         // 4B.2. modify pixmap following accessibility settings
         if ( bufferAccessibility )
         {
             switch ( Okular::SettingsCore::renderMode() )
             {
                 case Okular::SettingsCore::EnumRenderMode::Inverted:
                     // Invert image pixels using QImage internal function
                     backImage.invertPixels(QImage::InvertRgb);
                     break;
                 case Okular::SettingsCore::EnumRenderMode::Recolor:
                     recolor(&backImage, Okular::Settings::recolorForeground(), Okular::Settings::recolorBackground());
                     break;
                 case Okular::SettingsCore::EnumRenderMode::BlackWhite:
                     // Manual Gray and Contrast
                     unsigned int * data = (unsigned int *)backImage.bits();
                     int val, pixels = backImage.width() * backImage.height(),
                         con = Okular::Settings::bWContrast(), thr = 255 - Okular::Settings::bWThreshold();
                     for( int i = 0; i < pixels; ++i )
                     {
                         val = qGray( data[i] );
                         if ( val > thr )
                             val = 128 + (127 * (val - thr)) / (255 - thr);
                         else if ( val < thr )
                             val = (128 * val) / thr;
                         if ( con > 2 )
                         {
                             val = con * ( val - thr ) / 2 + thr;
                             if ( val > 255 )
                                 val = 255;
                             else if ( val < 0 )
                                 val = 0;
                         }
                         data[i] = qRgba( val, val, val, 255 );
                     }
                     break;
             }
         }
 
         // 4B.3. highlight rects in page
         if ( bufferedHighlights )
         {
             // draw highlights that are inside the 'limits' paint region
             QList< QPair<QColor, Okular::NormalizedRect> >::const_iterator hIt = bufferedHighlights->constBegin(), hEnd = bufferedHighlights->constEnd();
             for ( ; hIt != hEnd; ++hIt )
             {
                 const Okular::NormalizedRect & r = (*hIt).second;
                 // find out the rect to highlight on pixmap
 
                 QRect highlightRect = r.geometry( scaledWidth, scaledHeight ).translated( -scaledCrop.topLeft() ).intersected( limits );
                 highlightRect.translate( -limits.left(), -limits.top() );
 
                 QPainter painter(&backImage);
                 painter.fillRect(highlightRect, QColor((*hIt).first.red(), (*hIt).first.green(), (*hIt).first.blue(), 150));
 
                 // the code below works too, but the mordern method would be to just use a QPainter?
 
                 // highlight composition (product: highlight color * destcolor)
                 /*
                 QRect highlightRect = r.geometry( dScaledWidth, dScaledHeight ).translated( -dScaledCrop.topLeft() ).intersected( dLimits );
                 highlightRect.translate( -dLimits.left(), -dLimits.top() );
 
                 unsigned int * data = (unsigned int *)backImage.bits();
                 int val, newR, newG, newB,
                     rh = (*hIt).first.red(),
                     gh = (*hIt).first.green(),
                     bh = (*hIt).first.blue(),
                     offset = highlightRect.top() * backImage.width();
                 for( int y = highlightRect.top(); y <= highlightRect.bottom(); ++y )
                 {
                     for( int x = highlightRect.left(); x <= highlightRect.right(); ++x )
                     {
                         val = data[ x + offset ];
                         //for odt or epub
                         if(has_alpha)
                         {
                             newR = qRed(val);
                             newG = qGreen(val);
                             newB = qBlue(val);
 
                             if(newR == newG && newG == newB && newR == 0)
                                 newR = newG = newB = 255;
 
                             newR = (newR * rh) / 255;
                             newG = (newG * gh) / 255;
                             newB = (newB * bh) / 255;
                         }
                         else
                         {
                             newR = (qRed(val) * rh) / 255;
                             newG = (qGreen(val) * gh) / 255;
                             newB = (qBlue(val) * bh) / 255;
                         }
                         data[ x + offset ] = qRgba( newR, newG, newB, 255 );
                     }
                     offset += backImage.width();
                 }
                 }*/
             }
         }
 
         // 4B.4. paint annotations [COMPOSITED ONES]
         if ( bufferedAnnotations )
         {
             // Albert: This is quite "heavy" but all the backImage that reach here are QImage::Format_ARGB32_Premultiplied
             // and have to be so that the QPainter::CompositionMode_Multiply works
             // we could also put a
             // backImage = backImage.convertToFormat(QImage::Format_ARGB32_Premultiplied)
             // that would be almost a noop, but we'll leave the assert for now
             Q_ASSERT(backImage.format() == QImage::Format_ARGB32_Premultiplied);
             // precalc constants for normalizing [0,1] page coordinates into normalized [0,1] limit rect coordinates
             double pageScale = (double)croppedWidth / page->width();
             double xOffset = (double)limits.left() / (double)scaledWidth + crop.left,
                    xScale = (double)scaledWidth / (double)limits.width(),
                    yOffset = (double)limits.top() / (double)scaledHeight + crop.top,
                    yScale = (double)scaledHeight / (double)limits.height();
 
             // paint all buffered annotations in the page
             QList< Okular::Annotation * >::const_iterator aIt = bufferedAnnotations->constBegin(), aEnd = bufferedAnnotations->constEnd();
             for ( ; aIt != aEnd; ++aIt )
             {
                 Okular::Annotation * a = *aIt;
                 Okular::Annotation::SubType type = a->subType();
                 QColor acolor = a->style().color();
                 if ( !acolor.isValid() )
                     acolor = Qt::yellow;
                 acolor.setAlphaF( a->style().opacity() );
 
                 // draw LineAnnotation MISSING: all
                 if ( type == Okular::Annotation::ALine )
                 {
                     // get the annotation
                     Okular::LineAnnotation * la = (Okular::LineAnnotation *) a;
 
                     NormalizedPath path;
                     // normalize page point to image
                     const QLinkedList<Okular::NormalizedPoint> points = la->transformedLinePoints();
                     QLinkedList<Okular::NormalizedPoint>::const_iterator it = points.constBegin();
                     QLinkedList<Okular::NormalizedPoint>::const_iterator itEnd = points.constEnd();
                     for ( ; it != itEnd; ++it )
                     {
                         Okular::NormalizedPoint point;
                         point.x = ( (*it).x - xOffset) * xScale;
                         point.y = ( (*it).y - yOffset) * yScale;
                         path.append( point );
                     }
 
                     const QPen linePen = buildPen( a, a->style().width(), a->style().color() );
                     QBrush fillBrush;
 
                     if ( la->lineClosed() && la->lineInnerColor().isValid() )
                         fillBrush = QBrush( la->lineInnerColor() );
 
                     // draw the line as normalized path into image
                     drawShapeOnImage( backImage, path, la->lineClosed(),
                                       linePen,
                                       fillBrush, pageScale ,Multiply);
 
                     if ( path.count() == 2 && fabs( la->lineLeadingForwardPoint() ) > 0.1 )
                     {
                         Okular::NormalizedPoint delta( la->transformedLinePoints().last().x - la->transformedLinePoints().first().x, la->transformedLinePoints().first().y - la->transformedLinePoints().last().y );
                         double angle = atan2( delta.y, delta.x );
                         if ( delta.y < 0 )
                             angle += 2 * M_PI;
 
                         int sign = la->lineLeadingForwardPoint() > 0.0 ? 1 : -1;
                         double LLx = fabs( la->lineLeadingForwardPoint() ) * cos( angle + sign * M_PI_2 + 2 * M_PI ) / page->width();
                         double LLy = fabs( la->lineLeadingForwardPoint() ) * sin( angle + sign * M_PI_2 + 2 * M_PI ) / page->height();
 
                         NormalizedPath path2;
                         NormalizedPath path3;
 
                         Okular::NormalizedPoint point;
                         point.x = ( la->transformedLinePoints().first().x + LLx - xOffset ) * xScale;
                         point.y = ( la->transformedLinePoints().first().y - LLy - yOffset ) * yScale;
                         path2.append( point );
                         point.x = ( la->transformedLinePoints().last().x + LLx - xOffset ) * xScale;
                         point.y = ( la->transformedLinePoints().last().y - LLy - yOffset ) * yScale;
                         path3.append( point );
                         // do we have the extension on the "back"?
                         if ( fabs( la->lineLeadingBackwardPoint() ) > 0.1 )
                         {
                             double LLEx = la->lineLeadingBackwardPoint() * cos( angle - sign * M_PI_2 + 2 * M_PI ) / page->width();
                             double LLEy = la->lineLeadingBackwardPoint() * sin( angle - sign * M_PI_2 + 2 * M_PI ) / page->height();
                             point.x = ( la->transformedLinePoints().first().x + LLEx - xOffset ) * xScale;
                             point.y = ( la->transformedLinePoints().first().y - LLEy - yOffset ) * yScale;
                             path2.append( point );
                             point.x = ( la->transformedLinePoints().last().x + LLEx - xOffset ) * xScale;
                             point.y = ( la->transformedLinePoints().last().y - LLEy - yOffset ) * yScale;
                             path3.append( point );
                         }
                         else
                         {
                             path2.append( path[0] );
                             path3.append( path[1] );
                         }
 
                         drawShapeOnImage( backImage, path2, false, linePen, QBrush(), pageScale, Multiply );
                         drawShapeOnImage( backImage, path3, false, linePen, QBrush(), pageScale, Multiply );
                     }
                 }
                 // draw HighlightAnnotation MISSING: under/strike width, feather, capping
                 else if ( type == Okular::Annotation::AHighlight )
                 {
                     // get the annotation
                     Okular::HighlightAnnotation * ha = (Okular::HighlightAnnotation *) a;
                     Okular::HighlightAnnotation::HighlightType type = ha->highlightType();
 
                     // draw each quad of the annotation
                     int quads = ha->highlightQuads().size();
                     for ( int q = 0; q < quads; q++ )
                     {
                         NormalizedPath path;
                         const Okular::HighlightAnnotation::Quad & quad = ha->highlightQuads()[ q ];
                         // normalize page point to image
                         for ( int i = 0; i < 4; i++ )
                         {
                             Okular::NormalizedPoint point;
                             point.x = (quad.transformedPoint( i ).x - xOffset) * xScale;
                             point.y = (quad.transformedPoint( i ).y - yOffset) * yScale;
                             path.append( point );
                         }
                         // draw the normalized path into image
                         switch ( type )
                         {
                             // highlight the whole rect
                             case Okular::HighlightAnnotation::Highlight:
                                 drawShapeOnImage( backImage, path, true, Qt::NoPen, acolor, pageScale, Multiply );
                                 break;
                             // highlight the bottom part of the rect
                             case Okular::HighlightAnnotation::Squiggly:
                                 path[ 3 ].x = ( path[ 0 ].x + path[ 3 ].x ) / 2.0;
                                 path[ 3 ].y = ( path[ 0 ].y + path[ 3 ].y ) / 2.0;
                                 path[ 2 ].x = ( path[ 1 ].x + path[ 2 ].x ) / 2.0;
                                 path[ 2 ].y = ( path[ 1 ].y + path[ 2 ].y ) / 2.0;
                                 drawShapeOnImage( backImage, path, true, Qt::NoPen, acolor, pageScale, Multiply );
                                 break;
                             // make a line at 3/4 of the height
                             case Okular::HighlightAnnotation::Underline:
                                 path[ 0 ].x = ( 3 * path[ 0 ].x + path[ 3 ].x ) / 4.0;
                                 path[ 0 ].y = ( 3 * path[ 0 ].y + path[ 3 ].y ) / 4.0;
                                 path[ 1 ].x = ( 3 * path[ 1 ].x + path[ 2 ].x ) / 4.0;
                                 path[ 1 ].y = ( 3 * path[ 1 ].y + path[ 2 ].y ) / 4.0;
                                 path.pop_back();
                                 path.pop_back();
                                 drawShapeOnImage( backImage, path, false, QPen( acolor, 2 ), QBrush(), pageScale );
                                 break;
                             // make a line at 1/2 of the height
                             case Okular::HighlightAnnotation::StrikeOut:
                                 path[ 0 ].x = ( path[ 0 ].x + path[ 3 ].x ) / 2.0;
                                 path[ 0 ].y = ( path[ 0 ].y + path[ 3 ].y ) / 2.0;
                                 path[ 1 ].x = ( path[ 1 ].x + path[ 2 ].x ) / 2.0;
                                 path[ 1 ].y = ( path[ 1 ].y + path[ 2 ].y ) / 2.0;
                                 path.pop_back();
                                 path.pop_back();
                                 drawShapeOnImage( backImage, path, false, QPen( acolor, 2 ), QBrush(), pageScale );
                                 break;
                         }
                     }
                 }
                 // draw InkAnnotation MISSING:invar width, PENTRACER
                 else if ( type == Okular::Annotation::AInk )
                 {
                     // get the annotation
                     Okular::InkAnnotation * ia = (Okular::InkAnnotation *) a;
 
                     // draw each ink path
                     const QList< QLinkedList<Okular::NormalizedPoint> > transformedInkPaths = ia->transformedInkPaths();
 
                     const QPen inkPen = buildPen( a, a->style().width(), acolor );
 
                     int paths = transformedInkPaths.size();
                     for ( int p = 0; p < paths; p++ )
                     {
                         NormalizedPath path;
                         const QLinkedList<Okular::NormalizedPoint> & inkPath = transformedInkPaths[ p ];
 
                         // normalize page point to image
                         QLinkedList<Okular::NormalizedPoint>::const_iterator pIt = inkPath.constBegin(), pEnd = inkPath.constEnd();
                         for ( ; pIt != pEnd; ++pIt )
                         {
                             const Okular::NormalizedPoint & inkPoint = *pIt;
                             Okular::NormalizedPoint point;
                             point.x = (inkPoint.x - xOffset) * xScale;
                             point.y = (inkPoint.y - yOffset) * yScale;
                             path.append( point );
                         }
                         // draw the normalized path into image
                         drawShapeOnImage( backImage, path, false, inkPen, QBrush(), pageScale );
                     }
                 }
             } // end current annotation drawing
         }
         if(viewPortPoint)
         {
             QPainter painter(&backImage);
             painter.translate( -limits.left(), -limits.top() );
             painter.setPen( QApplication::palette().color( QPalette::Active, QPalette::Highlight ) );
             painter.drawLine( 0, viewPortPoint->y * scaledHeight + 1, scaledWidth - 1, viewPortPoint->y * scaledHeight + 1 );
 // ROTATION CURRENTLY NOT IMPLEMENTED
 /*
             if( page->rotation() == Okular::Rotation0)
             {
 
             }
             else if(page->rotation() == Okular::Rotation270)
             {
                 painter.drawLine( viewPortPoint->y * scaledHeight + 1, 0, viewPortPoint->y * scaledHeight + 1, scaledWidth - 1);
             }
             else if(page->rotation() == Okular::Rotation180)
             {
                 painter.drawLine( 0, (1.0 - viewPortPoint->y) * scaledHeight - 1, scaledWidth - 1, (1.0 - viewPortPoint->y) * scaledHeight - 1 );
             }
             else if(page->rotation() == Okular::Rotation90) // not right, rotation clock-wise
             {
                 painter.drawLine( scaledWidth - (viewPortPoint->y * scaledHeight + 1), 0, scaledWidth - (viewPortPoint->y * scaledHeight + 1), scaledWidth - 1);
             }
 */
         }
 
         // 4B.5. create the back pixmap converting from the local image
         backPixmap = new QPixmap( QPixmap::fromImage( backImage ) );
         backPixmap->setDevicePixelRatio(dpr);
 
         // 4B.6. create a painter over the pixmap and set it as the active one
         mixedPainter = new QPainter( backPixmap );
         mixedPainter->translate( -limits.left(), -limits.top() );
     }
 
     /** 5 -- MIXED FLOW. Draw ANNOTATIONS [OPAQUE ONES] on ACTIVE PAINTER  **/
     if ( unbufferedAnnotations )
     {
         // iterate over annotations and paint AText, AGeom, AStamp
         QList< Okular::Annotation * >::const_iterator aIt = unbufferedAnnotations->constBegin(), aEnd = unbufferedAnnotations->constEnd();
         for ( ; aIt != aEnd; ++aIt )
         {
             Okular::Annotation * a = *aIt;
 
             // honor opacity settings on supported types
             unsigned int opacity = (unsigned int)( 255.0 * a->style().opacity() );
             // skip the annotation drawing if all the annotation is fully
             // transparent, but not with text annotations
             if ( opacity <= 0 && a->subType() != Okular::Annotation::AText )
                 continue;
 
             QColor acolor = a->style().color();
             if ( !acolor.isValid() )
                 acolor = Qt::yellow;
             acolor.setAlpha( opacity );
 
             // get annotation boundary and drawn rect
             QRect annotBoundary = a->transformedBoundingRectangle().geometry( scaledWidth, scaledHeight ).translated( -scaledCrop.topLeft() );
             QRect annotRect = annotBoundary.intersected( limits );
             QRect innerRect( annotRect.left() - annotBoundary.left(), annotRect.top() -
                     annotBoundary.top(), annotRect.width(), annotRect.height() );
             QRectF dInnerRect(innerRect.x() * dpr, innerRect.y() * dpr, innerRect.width() * dpr, innerRect.height() * dpr);
 
             Okular::Annotation::SubType type = a->subType();
 
             // draw TextAnnotation
             if ( type == Okular::Annotation::AText )
             {
                 Okular::TextAnnotation * text = (Okular::TextAnnotation *)a;
                 if ( text->textType() == Okular::TextAnnotation::InPlace )
                 {
                     QImage image( annotBoundary.size(), QImage::Format_ARGB32 );
                     image.fill( acolor.rgba() );
                     QPainter painter( &image );
                     painter.setFont( text->textFont() );
                     Qt::AlignmentFlag halign = ( text->inplaceAlignment() == 1 ? Qt::AlignHCenter : ( text->inplaceAlignment() == 2 ? Qt::AlignRight : Qt::AlignLeft ) );
                     const double invXScale = (double)page->width() / scaledWidth;
                     const double invYScale = (double)page->height() / scaledHeight;
                     const double borderWidth = text->style().width();
                     painter.scale( 1 / invXScale, 1 / invYScale );
                     painter.drawText( borderWidth * invXScale, borderWidth * invYScale,
                                       (image.width() - 2 * borderWidth) * invXScale,
                                       (image.height() - 2 * borderWidth) * invYScale,
                                       Qt::AlignTop | halign | Qt::TextWrapAnywhere,
                                       text->contents() );
                     painter.resetTransform();
                     //Required as asking for a zero width pen results
                     //in a default width pen (1.0) being created
                     if ( borderWidth != 0 )
                     {
                         QPen pen( Qt::black, borderWidth );
                         painter.setPen( pen );
                         painter.drawRect( 0, 0, image.width() - 1, image.height() - 1 );
                     }
                     painter.end();
 
                     mixedPainter->drawImage( annotBoundary.topLeft(), image );
                 }
                 else if ( text->textType() == Okular::TextAnnotation::Linked )
                 {
                 // get pixmap, colorize and alpha-blend it
                     QString path;
                     QPixmap pixmap = GuiUtils::iconLoader()->loadIcon( text->textIcon().toLower(), KIconLoader::User, 32, KIconLoader::DefaultState, QStringList(), &path, true );
                     if ( path.isEmpty() )
                         pixmap = GuiUtils::iconLoader()->loadIcon( text->textIcon().toLower(), KIconLoader::NoGroup, 32 );
                     QRect annotBoundary2 = QRect( annotBoundary.topLeft(), QSize( TEXTANNOTATION_ICONSIZE * dpr, TEXTANNOTATION_ICONSIZE * dpr ) );
                     QRect annotRect2 = annotBoundary2.intersected( limits );
                     QRect innerRect2( annotRect2.left() - annotBoundary2.left(), annotRect2.top() -
                     annotBoundary2.top(), annotRect2.width(), annotRect2.height() );
 
                     QPixmap scaledCroppedPixmap = pixmap.scaled(TEXTANNOTATION_ICONSIZE * dpr, TEXTANNOTATION_ICONSIZE * dpr).copy(dInnerRect.toAlignedRect());
                     scaledCroppedPixmap.setDevicePixelRatio(dpr);
                     QImage scaledCroppedImage = scaledCroppedPixmap.toImage();
 
                     // if the annotation color is valid (ie it was set), then
                     // use it to colorize the icon, otherwise the icon will be
                     // "gray"
                     if ( a->style().color().isValid() )
                         GuiUtils::colorizeImage( scaledCroppedImage, a->style().color(), opacity );
                     pixmap = QPixmap::fromImage( scaledCroppedImage );
 
                     // draw the mangled image to painter
                     mixedPainter->drawPixmap( annotRect.topLeft(), pixmap);
                 }
 
             }
             // draw StampAnnotation
             else if ( type == Okular::Annotation::AStamp )
             {
                 Okular::StampAnnotation * stamp = (Okular::StampAnnotation *)a;
 
                 // get pixmap and alpha blend it if needed
                 QPixmap pixmap = GuiUtils::loadStamp( stamp->stampIconName(), annotBoundary.size() );
                 if ( !pixmap.isNull() ) // should never happen but can happen on huge sizes
                 {
                     const QRect dInnerRect(QRectF(innerRect.x() * dpr, innerRect.y() * dpr, innerRect.width() * dpr, innerRect.height() * dpr).toAlignedRect());
 
                     QPixmap scaledCroppedPixmap = pixmap.scaled(annotBoundary.width() * dpr, annotBoundary.height() * dpr).copy(dInnerRect);
                     scaledCroppedPixmap.setDevicePixelRatio(dpr);
 
                     QImage scaledCroppedImage = scaledCroppedPixmap.toImage();
 
                     if ( opacity < 255 )
                         changeImageAlpha( scaledCroppedImage, opacity );
                     pixmap = QPixmap::fromImage( scaledCroppedImage );
 
                     // draw the scaled and al
                     mixedPainter->drawPixmap( annotRect.topLeft(), pixmap );
                 }
             }
             // draw GeomAnnotation
             else if ( type == Okular::Annotation::AGeom )
             {
                 Okular::GeomAnnotation * geom = (Okular::GeomAnnotation *)a;
                 // check whether there's anything to draw
                 if ( geom->style().width() || geom->geometricalInnerColor().isValid() )
                 {
                     mixedPainter->save();
                     const double width = geom->style().width() * Okular::Utils::realDpi(nullptr).width() / ( 72.0 * 2.0 ) * scaledWidth / page->width();
                     QRectF r( .0, .0, annotBoundary.width(), annotBoundary.height() );
                     r.adjust( width, width, -width, -width );
                     r.translate( annotBoundary.topLeft() );
                     if ( geom->geometricalInnerColor().isValid() )
                     {
                         r.adjust( width, width, -width, -width );
                         const QColor color = geom->geometricalInnerColor();
                         mixedPainter->setPen( Qt::NoPen );
                         mixedPainter->setBrush( QColor( color.red(), color.green(), color.blue(), opacity ) );
                         if ( geom->geometricalType() == Okular::GeomAnnotation::InscribedSquare )
                             mixedPainter->drawRect( r );
                         else
                             mixedPainter->drawEllipse( r );
                         r.adjust( -width, -width, width, width );
                     }
                     if ( geom->style().width() ) // need to check the original size here..
                     {
                         mixedPainter->setPen( buildPen( a, width * 2, acolor ) );
                         mixedPainter->setBrush( Qt::NoBrush );
                         if ( geom->geometricalType() == Okular::GeomAnnotation::InscribedSquare )
                             mixedPainter->drawRect( r );
                         else
                             mixedPainter->drawEllipse( r );
                     }
                     mixedPainter->restore();
                 }
             }
 
             // draw extents rectangle
             if ( Okular::Settings::debugDrawAnnotationRect() )
             {
                 mixedPainter->setPen( a->style().color() );
                 mixedPainter->drawRect( annotBoundary );
             }
         }
     }
 
     if ( boundingRectOnlyAnn )
     {
         QRect annotBoundary = boundingRectOnlyAnn->transformedBoundingRectangle().geometry( scaledWidth, scaledHeight ).translated( -scaledCrop.topLeft() );
         mixedPainter->setPen( Qt::DashLine );
         mixedPainter->drawRect( annotBoundary );
     }
 
     /** 6 -- MIXED FLOW. Draw LINKS+IMAGES BORDER on ACTIVE PAINTER  **/
     if ( enhanceLinks || enhanceImages )
     {
         mixedPainter->save();
         mixedPainter->scale( scaledWidth, scaledHeight );
         mixedPainter->translate( -crop.left, -crop.top );
 
         QColor normalColor = QApplication::palette().color( QPalette::Active, QPalette::Highlight );
         // enlarging limits for intersection is like growing the 'rectGeometry' below
         QRect limitsEnlarged = limits;
         limitsEnlarged.adjust( -2, -2, 2, 2 );
         // draw rects that are inside the 'limits' paint region as opaque rects
         QLinkedList< Okular::ObjectRect * >::const_iterator lIt = page->m_rects.constBegin(), lEnd = page->m_rects.constEnd();
         for ( ; lIt != lEnd; ++lIt )
         {
             Okular::ObjectRect * rect = *lIt;
             if ( (enhanceLinks && rect->objectType() == Okular::ObjectRect::Action) ||
                  (enhanceImages && rect->objectType() == Okular::ObjectRect::Image) )
             {
                 if ( limitsEnlarged.intersects( rect->boundingRect( scaledWidth, scaledHeight ).translated( -scaledCrop.topLeft() ) ) )
                 {
                     mixedPainter->strokePath( rect->region(), QPen( normalColor, 0 ) );
                 }
             }
         }
         mixedPainter->restore();
     }
 
     /** 7 -- BUFFERED FLOW. Copy BACKPIXMAP on DESTINATION PAINTER **/
     if ( useBackBuffer )
     {
         delete mixedPainter;
         destPainter->drawPixmap( limits.left(), limits.top(), *backPixmap );
         delete backPixmap;
     }
 
     // delete object containers
     delete bufferedHighlights;
     delete bufferedAnnotations;
     delete unbufferedAnnotations;
     
     qDebug() << "PagePainter END";
 }
 
 
 /** Private Helpers :: Pixmap conversion **/
 void PagePainter::cropPixmapOnImage( QImage & dest, const QPixmap * src, const QRect & r )
 {
     qreal dpr = src->devicePixelRatioF();
 
     // handle quickly the case in which the whole pixmap has to be converted
     if ( r == QRect( 0, 0, src->width() / dpr, src->height() / dpr ) )
     {
         dest = src->toImage();
         dest = dest.convertToFormat(QImage::Format_ARGB32_Premultiplied);
     }
     // else copy a portion of the src to an internal pixmap (smaller) and convert it
     else
     {
         QImage croppedImage( r.width() * dpr, r.height() * dpr, QImage::Format_ARGB32_Premultiplied );
         croppedImage.setDevicePixelRatio(dpr);
         QPainter p( &croppedImage );
         p.drawPixmap( 0, 0, *src, r.left(), r.top(), r.width(), r.height() );
         p.end();
         dest = croppedImage;
     }
 }
 
 void PagePainter::recolor(QImage *image, const QColor &foreground, const QColor &background)
 {
     if (image->format() != QImage::Format_ARGB32_Premultiplied) {
         qCWarning(OkularUiDebug) << "Wrong image format! Converting...";
         *image = image->convertToFormat(QImage::Format_ARGB32_Premultiplied);
     }
 
     Q_ASSERT(image->format() == QImage::Format_ARGB32_Premultiplied);
 
     const float scaleRed = background.redF() - foreground.redF();
     const float scaleGreen = background.greenF() - foreground.greenF();
     const float scaleBlue = background.blueF() - foreground.blueF();
 
     for (int y=0; y<image->height(); y++) {
         QRgb *pixels = reinterpret_cast<QRgb*>(image->scanLine(y));
 
         for (int x=0; x<image->width(); x++) {
             const int lightness = qGray(pixels[x]);
             pixels[x] = qRgba(scaleRed * lightness + foreground.red(),
                            scaleGreen * lightness + foreground.green(),
                            scaleBlue * lightness + foreground.blue(),
                            qAlpha(pixels[x]));
         }
     }
 }
 
 /** Private Helpers :: Image Drawing **/
 // from Arthur - qt4
 static inline int qt_div_255(int x) { return (x + (x>>8) + 0x80) >> 8; }
 
 void PagePainter::changeImageAlpha( QImage & image, unsigned int destAlpha )
 {
     // iterate over all pixels changing the alpha component value
     unsigned int * data = (unsigned int *)image.bits();
     unsigned int pixels = image.width() * image.height();
 
     int source, sourceAlpha;
     for( unsigned int i = 0; i < pixels; ++i )
     {   // optimize this loop keeping byte order into account
         source = data[i];
         if ( (sourceAlpha = qAlpha( source )) == 255 )
         {
             // use destAlpha
             data[i] = qRgba( qRed(source), qGreen(source), qBlue(source), destAlpha );
         }
         else
         {
             // use destAlpha * sourceAlpha product
             sourceAlpha = qt_div_255( destAlpha * sourceAlpha );
             data[i] = qRgba( qRed(source), qGreen(source), qBlue(source), sourceAlpha );
         }
     }
 }
 
 void PagePainter::drawShapeOnImage(
     QImage & image,
     const NormalizedPath & normPath,
     bool closeShape,
     const QPen & pen,
     const QBrush & brush,
     double penWidthMultiplier,
     RasterOperation op
     //float antiAliasRadius
     )
 {
     // safety checks
     int pointsNumber = normPath.size();
     if ( pointsNumber < 2 )
         return;
 
     int imageWidth = image.width();
     int imageHeight = image.height();
     double fImageWidth = (double)imageWidth;
     double fImageHeight = (double)imageHeight;
 
     // stroke outline
     double penWidth = (double)pen.width() * penWidthMultiplier;
     QPainter painter(&image);
     painter.setRenderHint(QPainter::Antialiasing);
     QPen pen2 = pen;
     pen2.setWidthF(penWidth);
     painter.setPen(pen2);
     painter.setBrush(brush);
 
     if (op == Multiply) {
         painter.setCompositionMode(QPainter::CompositionMode_Multiply);
     }
 
     if ( brush.style() == Qt::NoBrush )
     {
         // create a polygon
         QPolygonF poly( closeShape ? pointsNumber + 1 : pointsNumber );
         for ( int i = 0; i < pointsNumber; ++i )
         {
             poly[ i ] = QPointF( normPath[ i ].x * fImageWidth, normPath[ i ].y * fImageHeight );
         }
         if ( closeShape )
             poly[ pointsNumber ] = poly[ 0 ];
 
         painter.drawPolyline( poly );
     }
     else
     {
         // create a 'path'
         QPainterPath path;
         path.setFillRule( Qt::WindingFill );
 
         path.moveTo( normPath[ 0 ].x * fImageWidth, normPath[ 0 ].y * fImageHeight );
         for ( int i = 1; i < pointsNumber; i++ )
         {
             path.lineTo( normPath[ i ].x * fImageWidth, normPath[ i ].y * fImageHeight );
         }
         if ( closeShape )
             path.closeSubpath();
 
         painter.drawPath( path );
     }
 }
 
 /* kate: replace-tabs on; indent-width 4; */
 
diff --git a/ui/pageview.cpp b/ui/pageview.cpp
index 11c50f8de..5a98d912b 100644
--- a/ui/pageview.cpp
+++ b/ui/pageview.cpp
@@ -1,5348 +1,5348 @@
 /***************************************************************************
  *   Copyright (C) 2004-2005 by Enrico Ros <eros.kde@email.it>             *
  *   Copyright (C) 2004-2006 by Albert Astals Cid <aacid@kde.org>          *
  *                                                                         *
  *   With portions of code from kpdf/kpdf_pagewidget.cc by:                *
  *     Copyright (C) 2002 by Wilco Greven <greven@kde.org>                 *
  *     Copyright (C) 2003 by Christophe Devriese                           *
  *                           <Christophe.Devriese@student.kuleuven.ac.be>  *
  *     Copyright (C) 2003 by Laurent Montel <montel@kde.org>               *
  *     Copyright (C) 2003 by Dirk Mueller <mueller@kde.org>                *
  *     Copyright (C) 2004 by James Ots <kde@jamesots.com>                  *
  *     Copyright (C) 2011 by Jiri Baum - NICTA <jiri@baum.com.au>          *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "pageview.h"
 
 // qt/kde includes
 #include <QtCore/qloggingcategory.h>
 #include <qcursor.h>
 #include <qevent.h>
 #include <qimage.h>
 #include <qpainter.h>
 #include <qtimer.h>
 #include <qset.h>
 #include <qscrollbar.h>
 #include <qtooltip.h>
 #include <qapplication.h>
 #include <qclipboard.h>
 #include <qmenu.h>
 #include <QInputDialog>
 #include <qdesktopwidget.h>
 #include <QDesktopServices>
 #include <QMimeDatabase>
 #include <QMimeData>
 #include <QGestureEvent>
 
 #include <qaction.h>
 #include <kactionmenu.h>
 #include <kstandardaction.h>
 #include <kactioncollection.h>
 #include <KLocalizedString>
 #include <kselectaction.h>
 #include <ktoggleaction.h>
 #include <QtCore/QDebug>
 #include <kmessagebox.h>
 #include <QIcon>
 #include <kurifilter.h>
 #include <kstringhandler.h>
 #include <ktoolinvocation.h>
 #include <krun.h>
 
 // system includes
 #include <math.h>
 #include <stdlib.h>
 
 // local includes
 #include "debug_ui.h"
 #include "formwidgets.h"
 #include "pageviewutils.h"
 #include "pagepainter.h"
 #include "core/annotations.h"
 #include "annotwindow.h"
 #include "guiutils.h"
 #include "annotationpopup.h"
 #include "pageviewannotator.h"
 #include "pageviewmouseannotation.h"
 #include "priorities.h"
 #include "toolaction.h"
 #include "okmenutitle.h"
 #ifdef HAVE_SPEECH
 #include "tts.h"
 #endif
 #include "videowidget.h"
 #include "core/action.h"
 #include "core/area.h"
 #include "core/document_p.h"
 #include "core/form.h"
 #include "core/page.h"
 #include "core/misc.h"
 #include "core/generator.h"
 #include "core/movie.h"
 #include "core/audioplayer.h"
 #include "core/sourcereference.h"
 #include "core/tile.h"
 #include "settings.h"
 #include "settings_core.h"
 #include "url_utils.h"
 #include "magnifierview.h"
 
 static const int pageflags = PagePainter::Accessibility | PagePainter::EnhanceLinks |
                        PagePainter::EnhanceImages | PagePainter::Highlights |
                        PagePainter::TextSelection | PagePainter::Annotations;
 
 static const float kZoomValues[] = { 0.12, 0.25, 0.33, 0.50, 0.66, 0.75, 1.00, 1.25, 1.50, 2.00, 4.00, 8.00, 16.00 };
 
 static inline double normClamp( double value, double def )
 {
     return ( value < 0.0 || value > 1.0 ) ? def : value;
 }
 
 struct TableSelectionPart {
     PageViewItem * item;
     Okular::NormalizedRect rectInItem;
     Okular::NormalizedRect rectInSelection;
 
     TableSelectionPart(PageViewItem * item_p, const Okular::NormalizedRect &rectInItem_p, const Okular::NormalizedRect &rectInSelection_p);
 };
 
 TableSelectionPart::TableSelectionPart(  PageViewItem * item_p, const Okular::NormalizedRect &rectInItem_p, const Okular::NormalizedRect &rectInSelection_p)
     : item ( item_p ), rectInItem (rectInItem_p), rectInSelection (rectInSelection_p)
 {
 }
 
 // structure used internally by PageView for data storage
 class PageViewPrivate
 {
 public:
     PageViewPrivate( PageView *qq );
 
     FormWidgetsController* formWidgetsController();
 #ifdef HAVE_SPEECH
     OkularTTS* tts();
 #endif
     QString selectedText() const;
 
     // the document, pageviewItems and the 'visible cache'
     PageView *q;
     Okular::Document * document;
     QVector< PageViewItem * > items;
     QLinkedList< PageViewItem * > visibleItems;
     MagnifierView *magnifierView;
 
     // view layout (columns and continuous in Settings), zoom and mouse
     PageView::ZoomMode zoomMode;
     float zoomFactor;
     QPoint mouseGrabPos;
     QPoint mousePressPos;
     QPoint mouseSelectPos;
     int mouseMidLastY;
     bool mouseSelecting;
     QRect mouseSelectionRect;
     QColor mouseSelectionColor;
     bool mouseTextSelecting;
     QSet< int > pagesWithTextSelection;
     bool mouseOnRect;
     int mouseMode;
     MouseAnnotation * mouseAnnotation;
 
     // table selection
     QList<double> tableSelectionCols;
     QList<double> tableSelectionRows;
     QList<TableSelectionPart> tableSelectionParts;
     bool tableDividersGuessed;
 
     // viewport move
     bool viewportMoveActive;
     QTime viewportMoveTime;
     QPoint viewportMoveDest;
     int lastSourceLocationViewportPageNumber;
     double lastSourceLocationViewportNormalizedX;
     double lastSourceLocationViewportNormalizedY;
     QTimer * viewportMoveTimer;
     int controlWheelAccumulatedDelta;
     // auto scroll
     int scrollIncrement;
     QTimer * autoScrollTimer;
     // annotations
     PageViewAnnotator * annotator;
     //text annotation dialogs list
     QHash< Okular::Annotation *, AnnotWindow * > m_annowindows;
     // other stuff
     QTimer * delayResizeEventTimer;
     bool dirtyLayout;
     bool blockViewport;                 // prevents changes to viewport
     bool blockPixmapsRequest;           // prevent pixmap requests
     PageViewMessage * messageWindow;    // in pageviewutils.h
     bool m_formsVisible;
     FormWidgetsController *formsWidgetController;
 #ifdef HAVE_SPEECH
     OkularTTS * m_tts;
 #endif
     QTimer * refreshTimer;
     QSet<int> refreshPages;
 
     // bbox state for Trim to Selection mode
     Okular::NormalizedRect trimBoundingBox;
 
     // infinite resizing loop prevention
     bool verticalScrollBarVisible;
     bool horizontalScrollBarVisible;
 
     // drag scroll
     QPoint dragScrollVector;
     QTimer dragScrollTimer;
 
     // left click depress
     QTimer leftClickTimer;
 
     // actions
     QAction * aRotateClockwise;
     QAction * aRotateCounterClockwise;
     QAction * aRotateOriginal;
     KSelectAction * aPageSizes;
     KActionMenu * aTrimMode;
     KToggleAction * aTrimMargins;
     QAction * aMouseNormal;
     QAction * aMouseSelect;
     QAction * aMouseTextSelect;
     QAction * aMouseTableSelect;
     QAction * aMouseMagnifier;
     KToggleAction * aTrimToSelection;
     KToggleAction * aToggleAnnotator;
     KSelectAction * aZoom;
     QAction * aZoomIn;
     QAction * aZoomOut;
     KToggleAction * aZoomFitWidth;
     KToggleAction * aZoomFitPage;
     KToggleAction * aZoomAutoFit;
     KActionMenu * aViewMode;
     KToggleAction * aViewContinuous;
     QAction * aPrevAction;
     QAction * aToggleForms;
     QAction * aSpeakDoc;
     QAction * aSpeakPage;
     QAction * aSpeakStop;
     KActionCollection * actionCollection;
     QActionGroup * mouseModeActionGroup;
     QAction * aFitWindowToPage;
 
     int setting_viewCols;
     bool rtl_Mode;
     // Keep track of whether tablet pen is currently pressed down
     bool penDown;
 };
 
 PageViewPrivate::PageViewPrivate( PageView *qq )
     : q( qq )
 #ifdef HAVE_SPEECH
     , m_tts( 0 )
 #endif
 {
 }
 
 FormWidgetsController* PageViewPrivate::formWidgetsController()
 {
     if ( !formsWidgetController )
     {
         formsWidgetController = new FormWidgetsController( document );
         QObject::connect( formsWidgetController, SIGNAL( changed( int ) ),
                           q, SLOT( slotFormChanged( int ) ) );
         QObject::connect( formsWidgetController, SIGNAL( action( Okular::Action* ) ),
                           q, SLOT( slotAction( Okular::Action* ) ) );
     }
 
     return formsWidgetController;
 }
 
 #ifdef HAVE_SPEECH
 OkularTTS* PageViewPrivate::tts()
 {
     if ( !m_tts )
     {
         m_tts = new OkularTTS( q );
         if ( aSpeakStop )
         {
             QObject::connect( m_tts, &OkularTTS::isSpeaking,
                               aSpeakStop, &QAction::setEnabled );
         }
     }
 
     return m_tts;
 }
 #endif
 
 
 /* PageView. What's in this file? -> quick overview.
  * Code weight (in rows) and meaning:
  *  160 - constructor and creating actions plus their connected slots (empty stuff)
  *  70  - DocumentObserver inherited methodes (important)
  *  550 - events: mouse, keyboard, drag
  *  170 - slotRelayoutPages: set contents of the scrollview on continuous/single modes
  *  100 - zoom: zooming pages in different ways, keeping update the toolbar actions, etc..
  *  other misc functions: only slotRequestVisiblePixmaps and pickItemOnPoint noticeable,
  * and many insignificant stuff like this comment :-)
  */
 PageView::PageView( QWidget *parent, Okular::Document *document )
     : QAbstractScrollArea( parent )
     , Okular::View( QLatin1String( "PageView" ) )
 {
     // create and initialize private storage structure
     d = new PageViewPrivate( this );
     d->document = document;
     d->aRotateClockwise = 0;
     d->aRotateCounterClockwise = 0;
     d->aRotateOriginal = 0;
     d->aViewMode = 0;
     d->zoomMode = PageView::ZoomFitWidth;
     d->zoomFactor = 1.0;
     d->mouseSelecting = false;
     d->mouseTextSelecting = false;
     d->mouseOnRect = false;
     d->mouseMode = Okular::Settings::mouseMode();
     d->mouseAnnotation = new MouseAnnotation( this, document );
     d->tableDividersGuessed = false;
     d->viewportMoveActive = false;
     d->lastSourceLocationViewportPageNumber = -1;
     d->lastSourceLocationViewportNormalizedX = 0.0;
     d->lastSourceLocationViewportNormalizedY = 0.0;
     d->viewportMoveTimer = 0;
     d->controlWheelAccumulatedDelta = 0;
     d->scrollIncrement = 0;
     d->autoScrollTimer = 0;
     d->annotator = 0;
     d->dirtyLayout = false;
     d->blockViewport = false;
     d->blockPixmapsRequest = false;
     d->messageWindow = new PageViewMessage(this);
     d->m_formsVisible = false;
     d->formsWidgetController = 0;
 #ifdef HAVE_SPEECH
     d->m_tts = 0;
 #endif
     d->refreshTimer = 0;
     d->aRotateClockwise = 0;
     d->aRotateCounterClockwise = 0;
     d->aRotateOriginal = 0;
     d->aPageSizes = 0;
     d->aTrimMode = 0;
     d->aTrimMargins = 0;
     d->aTrimToSelection = 0;
     d->aMouseNormal = 0;
     d->aMouseSelect = 0;
     d->aMouseTextSelect = 0;
     d->aToggleAnnotator = 0;
     d->aZoomFitWidth = 0;
     d->aZoomFitPage = 0;
     d->aZoomAutoFit = 0;
     d->aViewMode = 0;
     d->aViewContinuous = 0;
     d->aPrevAction = 0;
     d->aToggleForms = 0;
     d->aSpeakDoc = 0;
     d->aSpeakPage = 0;
     d->aSpeakStop = 0;
     d->actionCollection = 0;
     d->aPageSizes=0;
     d->setting_viewCols = Okular::Settings::viewColumns();
     d->rtl_Mode = Okular::Settings::rtlReadingDirection();
     d->mouseModeActionGroup = 0;
     d->penDown = false;
     d->aMouseMagnifier = 0;
     d->aFitWindowToPage = 0;
     d->trimBoundingBox = Okular::NormalizedRect(); // Null box
 
     switch( Okular::Settings::zoomMode() )
     {
         case 0:
         {
             d->zoomFactor = 1;
             d->zoomMode = PageView::ZoomFixed;
             break;
         }
         case 1:
         {
             d->zoomMode = PageView::ZoomFitWidth;
             break;
         }
         case 2:
         {
             d->zoomMode = PageView::ZoomFitPage;
             break;
         }
         case 3:
         {
             d->zoomMode = PageView::ZoomFitAuto;
             break;
         }
     }
 
     d->delayResizeEventTimer = new QTimer( this );
     d->delayResizeEventTimer->setSingleShot( true );
     connect( d->delayResizeEventTimer, &QTimer::timeout, this, &PageView::delayedResizeEvent );
 
     setFrameStyle(QFrame::NoFrame);
 
     setAttribute( Qt::WA_StaticContents );
 
     setObjectName( QStringLiteral( "okular::pageView" ) );
 
     // viewport setup: setup focus, and track mouse
     viewport()->setFocusProxy( this );
     viewport()->setFocusPolicy( Qt::StrongFocus );
     viewport()->setAttribute( Qt::WA_OpaquePaintEvent );
     viewport()->setAttribute( Qt::WA_NoSystemBackground );
     viewport()->setMouseTracking( true );
     viewport()->setAutoFillBackground( false );
     // the apparently "magic" value of 20 is the same used internally in QScrollArea
     verticalScrollBar()->setCursor( Qt::ArrowCursor );
     verticalScrollBar()->setSingleStep( 20 );
     horizontalScrollBar()->setCursor( Qt::ArrowCursor );
     horizontalScrollBar()->setSingleStep( 20 );
 
     // conntect the padding of the viewport to pixmaps requests
     connect(horizontalScrollBar(), &QAbstractSlider::valueChanged, this, &PageView::slotRequestVisiblePixmaps);
     connect(verticalScrollBar(), &QAbstractSlider::valueChanged, this, &PageView::slotRequestVisiblePixmaps);
     connect( &d->dragScrollTimer, &QTimer::timeout, this, &PageView::slotDragScroll );
 
     d->leftClickTimer.setSingleShot( true );
     connect( &d->leftClickTimer, &QTimer::timeout, this, &PageView::slotShowSizeAllCursor );
 
     // set a corner button to resize the view to the page size
 //    QPushButton * resizeButton = new QPushButton( viewport() );
 //    resizeButton->setPixmap( SmallIcon("crop") );
 //    setCornerWidget( resizeButton );
 //    resizeButton->setEnabled( false );
     // connect(...);
     setAttribute( Qt::WA_InputMethodEnabled, true );
 
     // Grab pinch gestures to zoom and rotate the view
     grabGesture(Qt::PinchGesture);
 
     d->magnifierView = new MagnifierView(document, this);
     d->magnifierView->hide();
     d->magnifierView->setGeometry(0, 0, 351, 201); // TODO: more dynamic?
 
     connect(document, &Okular::Document::processMovieAction, this, &PageView::slotProcessMovieAction);
     connect(document, &Okular::Document::processRenditionAction, this, &PageView::slotProcessRenditionAction);
 
     // schedule the welcome message
     QMetaObject::invokeMethod(this, "slotShowWelcome", Qt::QueuedConnection);
 }
 
 PageView::~PageView()
 {
 #ifdef HAVE_SPEECH
     if ( d->m_tts )
         d->m_tts->stopAllSpeechs();
 #endif
 
     delete d->mouseAnnotation;
 
     // delete the local storage structure
 
     // We need to assign it to a different list otherwise slotAnnotationWindowDestroyed
     // will bite us and clear d->m_annowindows
     QHash< Okular::Annotation *, AnnotWindow * > annowindows = d->m_annowindows;
     d->m_annowindows.clear();
     qDeleteAll( annowindows );
 
     // delete all widgets
     QVector< PageViewItem * >::const_iterator dIt = d->items.constBegin(), dEnd = d->items.constEnd();
     for ( ; dIt != dEnd; ++dIt )
         delete *dIt;
     delete d->formsWidgetController;
     d->document->removeObserver( this );
     delete d;
 }
 
 void PageView::setupBaseActions( KActionCollection * ac )
 {
     d->actionCollection = ac;
 
     // Zoom actions ( higher scales takes lots of memory! )
     d->aZoom  = new KSelectAction(QIcon::fromTheme( QStringLiteral("page-zoom") ), i18n("Zoom"), this);
     ac->addAction(QStringLiteral("zoom_to"), d->aZoom );
     d->aZoom->setEditable( true );
     d->aZoom->setMaxComboViewCount( 14 );
     connect( d->aZoom, SIGNAL(triggered(QAction*)), this, SLOT(slotZoom()) );
     updateZoomText();
 
     d->aZoomIn = KStandardAction::zoomIn( this, SLOT(slotZoomIn()), ac );
 
     d->aZoomOut = KStandardAction::zoomOut( this, SLOT(slotZoomOut()), ac );
 }
 
 void PageView::setupViewerActions( KActionCollection * ac )
 {
     d->actionCollection = ac;
 
     ac->setDefaultShortcut(d->aZoomIn, QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_Plus));
     ac->setDefaultShortcut(d->aZoomOut, QKeySequence(Qt::CTRL + Qt::ALT + Qt::Key_Minus));
 
     // orientation menu actions
     d->aRotateClockwise = new QAction( QIcon::fromTheme( QStringLiteral("object-rotate-right") ), i18n( "Rotate &Right" ), this );
     d->aRotateClockwise->setIconText( i18nc( "Rotate right", "Right" ) );
     ac->addAction( QStringLiteral("view_orientation_rotate_cw"), d->aRotateClockwise );
     d->aRotateClockwise->setEnabled( false );
     connect( d->aRotateClockwise, &QAction::triggered, this, &PageView::slotRotateClockwise );
     d->aRotateCounterClockwise = new QAction( QIcon::fromTheme( QStringLiteral("object-rotate-left") ), i18n( "Rotate &Left" ), this );
     d->aRotateCounterClockwise->setIconText( i18nc( "Rotate left", "Left" ) );
     ac->addAction( QStringLiteral("view_orientation_rotate_ccw"), d->aRotateCounterClockwise );
     d->aRotateCounterClockwise->setEnabled( false );
     connect( d->aRotateCounterClockwise, &QAction::triggered, this, &PageView::slotRotateCounterClockwise );
     d->aRotateOriginal = new QAction( i18n( "Original Orientation" ), this );
     ac->addAction( QStringLiteral("view_orientation_original"), d->aRotateOriginal );
     d->aRotateOriginal->setEnabled( false );
     connect( d->aRotateOriginal, &QAction::triggered, this, &PageView::slotRotateOriginal );
 
     d->aPageSizes = new KSelectAction(i18n("&Page Size"), this);
     ac->addAction(QStringLiteral("view_pagesizes"), d->aPageSizes);
     d->aPageSizes->setEnabled( false );
 
     connect( d->aPageSizes , SIGNAL(triggered(int)),
          this, SLOT(slotPageSizes(int)) );
 
     // Trim View actions
     d->aTrimMode = new KActionMenu(i18n( "&Trim View" ), this );
     d->aTrimMode->setDelayed( false );
     ac->addAction(QStringLiteral("view_trim_mode"), d->aTrimMode );
 
     d->aTrimMargins  = new KToggleAction( i18n( "&Trim Margins" ), d->aTrimMode->menu() );
     d->aTrimMode->addAction( d->aTrimMargins  );
     ac->addAction( QStringLiteral("view_trim_margins"), d->aTrimMargins  );
     d->aTrimMargins->setData( qVariantFromValue( (int)Okular::Settings::EnumTrimMode::Margins ) );
     connect( d->aTrimMargins, &QAction::toggled, this, &PageView::slotTrimMarginsToggled );
     d->aTrimMargins->setChecked( Okular::Settings::trimMargins() );
 
     d->aTrimToSelection  = new KToggleAction( i18n( "Trim To &Selection" ), d->aTrimMode->menu() );
     d->aTrimMode->addAction( d->aTrimToSelection);
     ac->addAction( QStringLiteral("view_trim_selection"), d->aTrimToSelection);
     d->aTrimToSelection->setData( qVariantFromValue( (int)Okular::Settings::EnumTrimMode::Selection ) );
     connect( d->aTrimToSelection, &QAction::toggled, this, &PageView::slotTrimToSelectionToggled );
 
     d->aZoomFitWidth  = new KToggleAction(QIcon::fromTheme( QStringLiteral("zoom-fit-width") ), i18n("Fit &Width"), this);
     ac->addAction(QStringLiteral("view_fit_to_width"), d->aZoomFitWidth );
     connect( d->aZoomFitWidth, &QAction::toggled, this, &PageView::slotFitToWidthToggled );
 
     d->aZoomFitPage  = new KToggleAction(QIcon::fromTheme( QStringLiteral("zoom-fit-best") ), i18n("Fit &Page"), this);
     ac->addAction(QStringLiteral("view_fit_to_page"), d->aZoomFitPage );
     connect( d->aZoomFitPage, &QAction::toggled, this, &PageView::slotFitToPageToggled );
 
     d->aZoomAutoFit  = new KToggleAction(QIcon::fromTheme( QStringLiteral("zoom-fit-best") ), i18n("&Auto Fit"), this);
     ac->addAction(QStringLiteral("view_auto_fit"), d->aZoomAutoFit );
     connect( d->aZoomAutoFit, &QAction::toggled, this, &PageView::slotAutoFitToggled );
 
     d->aFitWindowToPage = new QAction(QIcon::fromTheme( QStringLiteral("zoom-fit-width") ), i18n("Fit Wi&ndow to Page"), this);
     d->aFitWindowToPage->setEnabled( Okular::Settings::viewMode() == (int)Okular::Settings::EnumViewMode::Single );
     ac->setDefaultShortcut(d->aFitWindowToPage, QKeySequence(Qt::CTRL + Qt::Key_J) );
     ac->addAction( QStringLiteral("fit_window_to_page"), d->aFitWindowToPage );
     connect( d->aFitWindowToPage, &QAction::triggered, this, &PageView::slotFitWindowToPage );
 
     // View-Layout actions
     d->aViewMode = new KActionMenu( QIcon::fromTheme( QStringLiteral("view-split-left-right") ), i18n( "&View Mode" ), this );
     d->aViewMode->setDelayed( false );
 #define ADD_VIEWMODE_ACTION( text, name, id ) \
 do { \
     QAction *vm = new QAction( text, this ); \
     vm->setCheckable( true ); \
     vm->setData( qVariantFromValue( id ) ); \
     d->aViewMode->addAction( vm ); \
     ac->addAction( QStringLiteral(name), vm ); \
     vmGroup->addAction( vm ); \
 } while( 0 )
     ac->addAction(QStringLiteral("view_render_mode"), d->aViewMode );
     QActionGroup *vmGroup = new QActionGroup( this ); //d->aViewMode->menu() );
     ADD_VIEWMODE_ACTION( i18n( "Single Page" ), "view_render_mode_single", (int)Okular::Settings::EnumViewMode::Single );
     ADD_VIEWMODE_ACTION( i18n( "Facing Pages" ), "view_render_mode_facing", (int)Okular::Settings::EnumViewMode::Facing );
     ADD_VIEWMODE_ACTION( i18n( "Facing Pages (Center First Page)" ), "view_render_mode_facing_center_first", (int)Okular::Settings::EnumViewMode::FacingFirstCentered );
     ADD_VIEWMODE_ACTION( i18n( "Overview" ), "view_render_mode_overview", (int)Okular::Settings::EnumViewMode::Summary );
     const QList<QAction *> viewModeActions = d->aViewMode->menu()->actions();
     foreach(QAction *viewModeAction, viewModeActions)
     {
         if (viewModeAction->data().toInt() == Okular::Settings::viewMode())
         {
             viewModeAction->setChecked( true );
         }
     }
     connect( vmGroup, &QActionGroup::triggered, this, &PageView::slotViewMode );
 #undef ADD_VIEWMODE_ACTION
 
     d->aViewContinuous  = new KToggleAction(QIcon::fromTheme( QStringLiteral("view-list-text") ), i18n("&Continuous"), this);
     ac->addAction(QStringLiteral("view_continuous"), d->aViewContinuous );
     connect( d->aViewContinuous, &QAction::toggled, this, &PageView::slotContinuousToggled );
     d->aViewContinuous->setChecked( Okular::Settings::viewContinuous() );
 
     // Mouse mode actions for viewer mode
     d->mouseModeActionGroup = new QActionGroup( this );
     d->mouseModeActionGroup->setExclusive( true );
     d->aMouseNormal  = new QAction( QIcon::fromTheme( QStringLiteral("input-mouse") ), i18n( "&Browse Tool" ), this );
     ac->addAction(QStringLiteral("mouse_drag"), d->aMouseNormal );
     connect( d->aMouseNormal, &QAction::triggered, this, &PageView::slotSetMouseNormal );
     d->aMouseNormal->setIconText( i18nc( "Browse Tool", "Browse" ) );
     d->aMouseNormal->setCheckable( true );
     ac->setDefaultShortcut(d->aMouseNormal, QKeySequence(Qt::CTRL + Qt::Key_1));
     d->aMouseNormal->setActionGroup( d->mouseModeActionGroup );
     d->aMouseNormal->setChecked( Okular::Settings::mouseMode() == Okular::Settings::EnumMouseMode::Browse );
 
     QAction * mz  = new QAction(QIcon::fromTheme( QStringLiteral("page-zoom") ), i18n("&Zoom Tool"), this);
     ac->addAction(QStringLiteral("mouse_zoom"), mz );
     connect( mz, &QAction::triggered, this, &PageView::slotSetMouseZoom );
     mz->setIconText( i18nc( "Zoom Tool", "Zoom" ) );
     mz->setCheckable( true );
     ac->setDefaultShortcut(mz, QKeySequence(Qt::CTRL + Qt::Key_2));
     mz->setActionGroup( d->mouseModeActionGroup );
     mz->setChecked( Okular::Settings::mouseMode() == Okular::Settings::EnumMouseMode::Zoom );
 
     QAction * aToggleChangeColors  = new QAction(i18n("&Toggle Change Colors"), this);
     ac->addAction(QStringLiteral("toggle_change_colors"), aToggleChangeColors );
     connect( aToggleChangeColors, &QAction::triggered, this, &PageView::slotToggleChangeColors );
 }
 
 // WARNING: 'setupViewerActions' must have been called before this method
 void PageView::setupActions( KActionCollection * ac )
 {
     d->actionCollection = ac;
 
     ac->setDefaultShortcuts(d->aZoomIn, KStandardShortcut::zoomIn());
     ac->setDefaultShortcuts(d->aZoomOut, KStandardShortcut::zoomOut());
 
     // Mouse-Mode actions
     d->aMouseSelect  = new QAction(QIcon::fromTheme( QStringLiteral("select-rectangular") ), i18n("&Selection Tool"), this);
     ac->addAction(QStringLiteral("mouse_select"), d->aMouseSelect );
     connect( d->aMouseSelect, &QAction::triggered, this, &PageView::slotSetMouseSelect );
     d->aMouseSelect->setIconText( i18nc( "Select Tool", "Selection" ) );
     d->aMouseSelect->setCheckable( true );
     ac->setDefaultShortcut(d->aMouseSelect, Qt::CTRL + Qt::Key_3);
 
     d->aMouseSelect->setActionGroup( d->mouseModeActionGroup );
     d->aMouseSelect->setChecked( Okular::Settings::mouseMode() == Okular::Settings::EnumMouseMode::RectSelect );
 
     d->aMouseTextSelect  = new QAction(QIcon::fromTheme( QStringLiteral("draw-text") ), i18n("&Text Selection Tool"), this);
     ac->addAction(QStringLiteral("mouse_textselect"), d->aMouseTextSelect );
     connect( d->aMouseTextSelect, &QAction::triggered, this, &PageView::slotSetMouseTextSelect );
     d->aMouseTextSelect->setIconText( i18nc( "Text Selection Tool", "Text Selection" ) );
     d->aMouseTextSelect->setCheckable( true );
     ac->setDefaultShortcut(d->aMouseTextSelect, Qt::CTRL + Qt::Key_4);
     d->aMouseTextSelect->setActionGroup( d->mouseModeActionGroup );
     d->aMouseTextSelect->setChecked( Okular::Settings::mouseMode() == Okular::Settings::EnumMouseMode::TextSelect );
 
     d->aMouseTableSelect  = new QAction(QIcon::fromTheme( QStringLiteral("table") ), i18n("T&able Selection Tool"), this);
     ac->addAction(QStringLiteral("mouse_tableselect"), d->aMouseTableSelect );
     connect( d->aMouseTableSelect, &QAction::triggered, this, &PageView::slotSetMouseTableSelect );
     d->aMouseTableSelect->setIconText( i18nc( "Table Selection Tool", "Table Selection" ) );
     d->aMouseTableSelect->setCheckable( true );
     ac->setDefaultShortcut(d->aMouseTableSelect, Qt::CTRL + Qt::Key_5);
     d->aMouseTableSelect->setActionGroup( d->mouseModeActionGroup );
     d->aMouseTableSelect->setChecked( Okular::Settings::mouseMode() == Okular::Settings::EnumMouseMode::TableSelect );
 
     d->aMouseMagnifier = new QAction(QIcon::fromTheme( QStringLiteral("document-preview") ), i18n("&Magnifier"), this);
     ac->addAction(QStringLiteral("mouse_magnifier"), d->aMouseMagnifier );
     connect( d->aMouseMagnifier, &QAction::triggered, this, &PageView::slotSetMouseMagnifier );
     d->aMouseMagnifier->setIconText( i18nc( "Magnifier Tool", "Magnifier" ) );
     d->aMouseMagnifier->setCheckable( true );
     ac->setDefaultShortcut(d->aMouseMagnifier, Qt::CTRL + Qt::Key_6);
     d->aMouseMagnifier->setActionGroup( d->mouseModeActionGroup );
     d->aMouseMagnifier->setChecked( Okular::Settings::mouseMode() == Okular::Settings::EnumMouseMode::Magnifier );
 
     d->aToggleAnnotator  = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-freehand") ), i18n("&Review"), this);
     ac->addAction(QStringLiteral("mouse_toggle_annotate"), d->aToggleAnnotator );
     d->aToggleAnnotator->setCheckable( true );
     connect( d->aToggleAnnotator, &QAction::toggled, this, &PageView::slotToggleAnnotator );
     ac->setDefaultShortcut(d->aToggleAnnotator, Qt::Key_F6);
 
     ToolAction *ta = new ToolAction( this );
     ac->addAction( QStringLiteral("mouse_selecttools"), ta );
     ta->addAction( d->aMouseSelect );
     ta->addAction( d->aMouseTextSelect );
     ta->addAction( d->aMouseTableSelect );
 
     // speak actions
 #ifdef HAVE_SPEECH
     d->aSpeakDoc = new QAction( QIcon::fromTheme( QStringLiteral("text-speak") ), i18n( "Speak Whole Document" ), this );
     ac->addAction( QStringLiteral("speak_document"), d->aSpeakDoc );
     d->aSpeakDoc->setEnabled( false );
     connect( d->aSpeakDoc, &QAction::triggered, this, &PageView::slotSpeakDocument );
 
     d->aSpeakPage = new QAction( QIcon::fromTheme( QStringLiteral("text-speak") ), i18n( "Speak Current Page" ), this );
     ac->addAction( QStringLiteral("speak_current_page"), d->aSpeakPage );
     d->aSpeakPage->setEnabled( false );
     connect( d->aSpeakPage, &QAction::triggered, this, &PageView::slotSpeakCurrentPage );
 
     d->aSpeakStop = new QAction( QIcon::fromTheme( QStringLiteral("media-playback-stop") ), i18n( "Stop Speaking" ), this );
     ac->addAction( QStringLiteral("speak_stop_all"), d->aSpeakStop );
     d->aSpeakStop->setEnabled( false );
     connect( d->aSpeakStop, &QAction::triggered, this, &PageView::slotStopSpeaks );
 #else
     d->aSpeakDoc = 0;
     d->aSpeakPage = 0;
     d->aSpeakStop = 0;
 #endif
 
     // Other actions
     QAction * su  = new QAction(i18n("Scroll Up"), this);
     ac->addAction(QStringLiteral("view_scroll_up"), su );
     connect( su, &QAction::triggered, this, &PageView::slotAutoScrollUp );
     ac->setDefaultShortcut(su, QKeySequence(Qt::SHIFT + Qt::Key_Up));
     addAction(su);
 
     QAction * sd  = new QAction(i18n("Scroll Down"), this);
     ac->addAction(QStringLiteral("view_scroll_down"), sd );
     connect( sd, &QAction::triggered, this, &PageView::slotAutoScrollDown );
     ac->setDefaultShortcut(sd, QKeySequence(Qt::SHIFT + Qt::Key_Down));
     addAction(sd);
 
     QAction * spu = new QAction(i18n("Scroll Page Up"), this);
     ac->addAction( QStringLiteral("view_scroll_page_up"), spu );
     connect( spu, &QAction::triggered, this, &PageView::slotScrollUp );
     ac->setDefaultShortcut(spu, QKeySequence(Qt::SHIFT + Qt::Key_Space));
     addAction( spu );
 
     QAction * spd = new QAction(i18n("Scroll Page Down"), this);
     ac->addAction( QStringLiteral("view_scroll_page_down"), spd );
     connect( spd, &QAction::triggered, this, &PageView::slotScrollDown );
     ac->setDefaultShortcut(spd, QKeySequence(Qt::Key_Space));
     addAction( spd );
 
     d->aToggleForms = new QAction( this );
     ac->addAction( QStringLiteral("view_toggle_forms"), d->aToggleForms );
     connect( d->aToggleForms, &QAction::triggered, this, &PageView::slotToggleForms );
     d->aToggleForms->setEnabled( false );
     toggleFormWidgets( false );
 
     // Setup undo and redo actions
     QAction *kundo = KStandardAction::create( KStandardAction::Undo, d->document, SLOT(undo()), ac );
     QAction *kredo = KStandardAction::create( KStandardAction::Redo, d->document, SLOT(redo()), ac );
     connect(d->document, &Okular::Document::canUndoChanged, kundo, &QAction::setEnabled);
     connect(d->document, &Okular::Document::canRedoChanged, kredo, &QAction::setEnabled);
     kundo->setEnabled(false);
     kredo->setEnabled(false);
 }
 
 bool PageView::canFitPageWidth() const
 {
     return Okular::Settings::viewMode() != Okular::Settings::EnumViewMode::Single || d->zoomMode != ZoomFitWidth;
 }
 
 void PageView::fitPageWidth( int page )
 {
     // zoom: Fit Width, columns: 1. setActions + relayout + setPage + update
     d->zoomMode = ZoomFitWidth;
     Okular::Settings::setViewMode( 0 );
     d->aZoomFitWidth->setChecked( true );
     d->aZoomFitPage->setChecked( false );
     d->aZoomAutoFit->setChecked( false );
     d->aViewMode->menu()->actions().at( 0 )->setChecked( true );
     viewport()->setUpdatesEnabled( false );
     slotRelayoutPages();
     viewport()->setUpdatesEnabled( true );
     d->document->setViewportPage( page );
     updateZoomText();
     setFocus();
 }
 
 void PageView::openAnnotationWindow( Okular::Annotation * annotation, int pageNumber )
 {
     if ( !annotation )
         return;
 
     // find the annot window
     AnnotWindow* existWindow = 0;
     QHash< Okular::Annotation *, AnnotWindow * >::ConstIterator it = d->m_annowindows.constFind( annotation );
     if ( it != d->m_annowindows.constEnd() )
     {
         existWindow = *it;
     }
 
     if ( existWindow == 0 )
     {
         existWindow = new AnnotWindow( this, annotation, d->document, pageNumber );
         connect(existWindow, &QObject::destroyed, this, &PageView::slotAnnotationWindowDestroyed);
 
         d->m_annowindows.insert( annotation, existWindow );
     }
 
     existWindow->show();
 }
 
 void PageView::slotAnnotationWindowDestroyed( QObject * window )
 {
     QHash< Okular::Annotation*, AnnotWindow * >::Iterator it = d->m_annowindows.begin();
     QHash< Okular::Annotation*, AnnotWindow * >::Iterator itEnd = d->m_annowindows.end();
     while ( it != itEnd )
     {
         if ( it.value() == window )
         {
             it = d->m_annowindows.erase( it );
         }
         else
         {
             ++it;
         }
     }
 }
 
 void PageView::displayMessage( const QString & message, const QString & details, PageViewMessage::Icon icon, int duration )
 {
     if ( !Okular::Settings::showOSD() )
     {
         if (icon == PageViewMessage::Error)
         {
             if ( !details.isEmpty() )
                 KMessageBox::detailedError( this, message, details );
             else
                 KMessageBox::error( this, message );
         }
         return;
     }
 
     // hide messageWindow if string is empty
     if ( message.isEmpty() )
         return d->messageWindow->hide();
 
     // display message (duration is length dependant)
     if (duration==-1)
     {
         duration = 500 + 100 * message.length();
         if ( !details.isEmpty() )
             duration += 500 + 100 * details.length();
     }
     d->messageWindow->display( message, details, icon, duration );
 }
 
 void PageView::reparseConfig()
 {
     // set the scroll bars policies
     Qt::ScrollBarPolicy scrollBarMode = Okular::Settings::showScrollBars() ?
         Qt::ScrollBarAsNeeded : Qt::ScrollBarAlwaysOff;
     if ( horizontalScrollBarPolicy() != scrollBarMode )
     {
         setHorizontalScrollBarPolicy( scrollBarMode );
         setVerticalScrollBarPolicy( scrollBarMode );
     }
 
     if ( Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Summary &&
          ( (int)Okular::Settings::viewColumns() != d->setting_viewCols ) )
     {
         d->setting_viewCols = Okular::Settings::viewColumns();
 
         slotRelayoutPages();
     }
 
     if (Okular::Settings::rtlReadingDirection() != d->rtl_Mode )
     {
         d->rtl_Mode = Okular::Settings::rtlReadingDirection();
         slotRelayoutPages();
     }
 
     updatePageStep();
 
     if ( d->annotator )
     {
         d->annotator->setEnabled( false );
         d->annotator->reparseConfig();
         if ( d->aToggleAnnotator->isChecked() )
             slotToggleAnnotator( true );
     }
 
     // Something like invert colors may have changed
     // As we don't have a way to find out the old value
     // We just update the viewport, this shouldn't be that bad
     // since it's just a repaint of pixmaps we already have
     viewport()->update();
 }
 
 KActionCollection *PageView::actionCollection() const
 {
     return d->actionCollection;
 }
 
 QAction *PageView::toggleFormsAction() const
 {
     return d->aToggleForms;
 }
 
 int PageView::contentAreaWidth() const
 {
     return horizontalScrollBar()->maximum() + viewport()->width();
 }
 
 int PageView::contentAreaHeight() const
 {
     return verticalScrollBar()->maximum() + viewport()->height();
 }
 
 QPoint PageView::contentAreaPosition() const
 {
     return QPoint( horizontalScrollBar()->value(), verticalScrollBar()->value() );
 }
 
 QPoint PageView::contentAreaPoint( const QPoint & pos ) const
 {
     return pos + contentAreaPosition();
 }
 
 QPointF PageView::contentAreaPoint( const QPointF & pos ) const
 {
     return pos + contentAreaPosition();
 }
 
 QString PageViewPrivate::selectedText() const
 {
     if ( pagesWithTextSelection.isEmpty() )
         return QString();
 
     QString text;
     QList< int > selpages = pagesWithTextSelection.toList();
     qSort( selpages );
     const Okular::Page * pg = 0;
     if ( selpages.count() == 1 )
     {
         pg = document->page( selpages.first() );
         text.append( pg->text( pg->textSelection(), Okular::TextPage::CentralPixelTextAreaInclusionBehaviour ) );
     }
     else
     {
         pg = document->page( selpages.first() );
         text.append( pg->text( pg->textSelection(), Okular::TextPage::CentralPixelTextAreaInclusionBehaviour ) );
         int end = selpages.count() - 1;
         for( int i = 1; i < end; ++i )
         {
             pg = document->page( selpages.at( i ) );
             text.append( pg->text( 0, Okular::TextPage::CentralPixelTextAreaInclusionBehaviour ) );
         }
         pg = document->page( selpages.last() );
         text.append( pg->text( pg->textSelection(), Okular::TextPage::CentralPixelTextAreaInclusionBehaviour ) );
     }
     return text;
 }
 
 void PageView::copyTextSelection() const
 {
     const QString text = d->selectedText();
     if ( !text.isEmpty() )
     {
         QClipboard *cb = QApplication::clipboard();
         cb->setText( text, QClipboard::Clipboard );
     }
 }
 
 void PageView::selectAll()
 {
     QVector< PageViewItem * >::const_iterator it = d->items.constBegin(), itEnd = d->items.constEnd();
     for ( ; it < itEnd; ++it )
     {
         Okular::RegularAreaRect * area = textSelectionForItem( *it );
         d->pagesWithTextSelection.insert( (*it)->pageNumber() );
         d->document->setPageTextSelection( (*it)->pageNumber(), area, palette().color( QPalette::Active, QPalette::Highlight ) );
     }
 }
 
 //BEGIN DocumentObserver inherited methods
 void PageView::notifySetup( const QVector< Okular::Page * > & pageSet, int setupFlags )
 {
     bool documentChanged = setupFlags & Okular::DocumentObserver::DocumentChanged;
     // reuse current pages if nothing new
     if ( ( pageSet.count() == d->items.count() ) && !documentChanged && !( setupFlags & Okular::DocumentObserver::NewLayoutForPages ) )
     {
         int count = pageSet.count();
         for ( int i = 0; (i < count) && !documentChanged; i++ )
             if ( (int)pageSet[i]->number() != d->items[i]->pageNumber() )
                 documentChanged = true;
         if ( !documentChanged )
             return;
     }
 
     // mouseAnnotation must not access our PageViewItem widgets any longer
     d->mouseAnnotation->reset();
 
     // delete all widgets (one for each page in pageSet)
     QVector< PageViewItem * >::const_iterator dIt = d->items.constBegin(), dEnd = d->items.constEnd();
     for ( ; dIt != dEnd; ++dIt )
         delete *dIt;
     d->items.clear();
     d->visibleItems.clear();
     d->pagesWithTextSelection.clear();
     toggleFormWidgets( false );
     if ( d->formsWidgetController )
         d->formsWidgetController->dropRadioButtons();
 
     bool haspages = !pageSet.isEmpty();
     bool hasformwidgets = false;
     // create children widgets
     QVector< Okular::Page * >::const_iterator setIt = pageSet.constBegin(), setEnd = pageSet.constEnd();
     for ( ; setIt != setEnd; ++setIt )
     {
-        PageViewItem * item = new PageViewItem( *setIt, devicePixelRatio() );
+        PageViewItem * item = new PageViewItem( *setIt );
         d->items.push_back( item );
 #ifdef PAGEVIEW_DEBUG
         qCDebug(OkularUiDebug).nospace() << "cropped geom for " << d->items.last()->pageNumber() << " is " << d->items.last()->croppedGeometry();
 #endif
         const QLinkedList< Okular::FormField * > pageFields = (*setIt)->formFields();
         QLinkedList< Okular::FormField * >::const_iterator ffIt = pageFields.constBegin(), ffEnd = pageFields.constEnd();
         for ( ; ffIt != ffEnd; ++ffIt )
         {
             Okular::FormField * ff = *ffIt;
             FormWidgetIface * w = FormWidgetFactory::createWidget( ff, viewport() );
             if ( w )
             {
                 w->setPageItem( item );
                 w->setFormWidgetsController( d->formWidgetsController() );
                 w->setVisibility( false );
                 w->setCanBeFilled( d->document->isAllowed( Okular::AllowFillForms ) );
                 item->formWidgets().insert( ff->id(), w );
                 hasformwidgets = true;
             }
         }
         const QLinkedList< Okular::Annotation * > annotations = (*setIt)->annotations();
         QLinkedList< Okular::Annotation * >::const_iterator aIt = annotations.constBegin(), aEnd = annotations.constEnd();
         for ( ; aIt != aEnd; ++aIt )
         {
             Okular::Annotation * a = *aIt;
             if ( a->subType() == Okular::Annotation::AMovie )
             {
                 Okular::MovieAnnotation * movieAnn = static_cast< Okular::MovieAnnotation * >( a );
                 VideoWidget * vw = new VideoWidget( movieAnn, movieAnn->movie(), d->document, viewport() );
                 item->videoWidgets().insert( movieAnn->movie(), vw );
                 vw->pageInitialized();
             }
             else if ( a->subType() == Okular::Annotation::ARichMedia )
             {
                 Okular::RichMediaAnnotation * richMediaAnn = static_cast< Okular::RichMediaAnnotation * >( a );
                 VideoWidget * vw = new VideoWidget( richMediaAnn, richMediaAnn->movie(), d->document, viewport() );
                 item->videoWidgets().insert( richMediaAnn->movie(), vw );
                 vw->pageInitialized();
             }
             else if ( a->subType() == Okular::Annotation::AScreen )
             {
                 const Okular::ScreenAnnotation * screenAnn = static_cast< Okular::ScreenAnnotation * >( a );
                 Okular::Movie *movie = GuiUtils::renditionMovieFromScreenAnnotation( screenAnn );
                 if ( movie )
                 {
                     VideoWidget * vw = new VideoWidget( screenAnn, movie, d->document, viewport() );
                     item->videoWidgets().insert( movie, vw );
                     vw->pageInitialized();
                 }
             }
         }
     }
 
     // invalidate layout so relayout/repaint will happen on next viewport change
     if ( haspages )
     {
         // We do a delayed call to slotRelayoutPages but also set the dirtyLayout
         // because we might end up in notifyViewportChanged while slotRelayoutPages
         // has not been done and we don't want that to happen
         d->dirtyLayout = true;
         QMetaObject::invokeMethod(this, "slotRelayoutPages", Qt::QueuedConnection);
     }
     else
     {
         // update the mouse cursor when closing because we may have close through a link and
         // want the cursor to come back to the normal cursor
         updateCursor();
         // then, make the message window and scrollbars disappear, and trigger a repaint
         d->messageWindow->hide();
         resizeContentArea( QSize( 0,0 ) );
         viewport()->update(); // when there is no change to the scrollbars, no repaint would
                               // be done and the old document would still be shown
     }
 
     // OSD to display pages
     if ( documentChanged && pageSet.count() > 0 && Okular::Settings::showOSD() )
         d->messageWindow->display(
             i18np(" Loaded a one-page document.",
                  " Loaded a %1-page document.",
                  pageSet.count() ),
             QString(),
             PageViewMessage::Info, 4000 );
 
     updateActionState( haspages, documentChanged, hasformwidgets );
 
     // We need to assign it to a different list otherwise slotAnnotationWindowDestroyed
     // will bite us and clear d->m_annowindows
     QHash< Okular::Annotation *, AnnotWindow * > annowindows = d->m_annowindows;
     d->m_annowindows.clear();
     qDeleteAll( annowindows );
 
     selectionClear();
 }
 
 void PageView::updateActionState( bool haspages, bool documentChanged, bool hasformwidgets )
 {
     if ( d->aPageSizes )
     { // may be null if dummy mode is on
         bool pageSizes = d->document->supportsPageSizes();
         d->aPageSizes->setEnabled( pageSizes );
         // set the new page sizes:
         // - if the generator supports them
         // - if the document changed
         if ( pageSizes && documentChanged )
         {
             QStringList items;
             foreach ( const Okular::PageSize &p, d->document->pageSizes() )
                 items.append( p.name() );
             d->aPageSizes->setItems( items );
         }
     }
 
     if ( d->aTrimMargins )
         d->aTrimMargins->setEnabled( haspages );
 
     if ( d->aTrimToSelection )
         d->aTrimToSelection->setEnabled( haspages );
 
     if ( d->aViewMode )
         d->aViewMode->setEnabled( haspages );
 
     if ( d->aViewContinuous )
         d->aViewContinuous->setEnabled( haspages );
 
     if ( d->aZoomFitWidth )
         d->aZoomFitWidth->setEnabled( haspages );
     if ( d->aZoomFitPage )
         d->aZoomFitPage->setEnabled( haspages );
     if ( d->aZoomAutoFit )
         d->aZoomAutoFit->setEnabled( haspages );
 
     if ( d->aZoom )
     {
         d->aZoom->selectableActionGroup()->setEnabled( haspages );
         d->aZoom->setEnabled( haspages );
     }
     if ( d->aZoomIn )
         d->aZoomIn->setEnabled( haspages );
     if ( d->aZoomOut )
         d->aZoomOut->setEnabled( haspages );
 
     if ( d->mouseModeActionGroup )
         d->mouseModeActionGroup->setEnabled( haspages );
 
     if ( d->aRotateClockwise )
         d->aRotateClockwise->setEnabled( haspages );
     if ( d->aRotateCounterClockwise )
         d->aRotateCounterClockwise->setEnabled( haspages );
     if ( d->aRotateOriginal )
         d->aRotateOriginal->setEnabled( haspages );
     if ( d->aToggleForms )
     { // may be null if dummy mode is on
         d->aToggleForms->setEnabled( haspages && hasformwidgets );
     }
     bool allowAnnotations = d->document->isAllowed( Okular::AllowNotes );
     if ( d->annotator )
     {
         bool allowTools = haspages && allowAnnotations;
         d->annotator->setToolsEnabled( allowTools );
         d->annotator->setTextToolsEnabled( allowTools && d->document->supportsSearching() );
     }
     if ( d->aToggleAnnotator )
     {
         if ( !allowAnnotations && d->aToggleAnnotator->isChecked() )
         {
             d->aToggleAnnotator->trigger();
         }
         d->aToggleAnnotator->setEnabled( allowAnnotations );
     }
 #ifdef HAVE_SPEECH
     if ( d->aSpeakDoc )
     {
         const bool enablettsactions = haspages ? Okular::Settings::useTTS() : false;
         d->aSpeakDoc->setEnabled( enablettsactions );
         d->aSpeakPage->setEnabled( enablettsactions );
     }
 #endif
     if (d->aMouseMagnifier)
         d->aMouseMagnifier->setEnabled(d->document->supportsTiles());
     if ( d->aFitWindowToPage )
         d->aFitWindowToPage->setEnabled( haspages && !Okular::Settings::viewContinuous() );
 }
 
 bool PageView::areSourceLocationsShownGraphically() const
 {
     return Okular::Settings::showSourceLocationsGraphically();
 }
 
 void PageView::setShowSourceLocationsGraphically(bool show)
 {
     if( show == Okular::Settings::showSourceLocationsGraphically() )
     {
         return;
     }
     Okular::Settings::setShowSourceLocationsGraphically( show );
     viewport()->update();
 }
 
 void PageView::setLastSourceLocationViewport( const Okular::DocumentViewport& vp )
 {
     if( vp.rePos.enabled )
     {
         d->lastSourceLocationViewportNormalizedX = normClamp( vp.rePos.normalizedX, 0.5 );
         d->lastSourceLocationViewportNormalizedY = normClamp( vp.rePos.normalizedY, 0.0 );
     }
     else
     {
         d->lastSourceLocationViewportNormalizedX = 0.5;
         d->lastSourceLocationViewportNormalizedY = 0.0;
     }
     d->lastSourceLocationViewportPageNumber = vp.pageNumber;
     viewport()->update();
 }
 
 void PageView::clearLastSourceLocationViewport()
 {
     d->lastSourceLocationViewportPageNumber = -1;
     d->lastSourceLocationViewportNormalizedX = 0.0;
     d->lastSourceLocationViewportNormalizedY = 0.0;
     viewport()->update();
 }
 
 void PageView::notifyViewportChanged( bool smoothMove )
 {
     QMetaObject::invokeMethod(this, "slotRealNotifyViewportChanged", Qt::QueuedConnection, Q_ARG( bool, smoothMove ));
 }
 
 void PageView::slotRealNotifyViewportChanged( bool smoothMove )
 {
     // if we are the one changing viewport, skip this nofity
     if ( d->blockViewport )
         return;
 
     // block setViewport outgoing calls
     d->blockViewport = true;
 
     // find PageViewItem matching the viewport description
     const Okular::DocumentViewport & vp = d->document->viewport();
     PageViewItem * item = 0;
     QVector< PageViewItem * >::const_iterator iIt = d->items.constBegin(), iEnd = d->items.constEnd();
     for ( ; iIt != iEnd; ++iIt )
         if ( (*iIt)->pageNumber() == vp.pageNumber )
         {
             item = *iIt;
             break;
         }
     if ( !item )
     {
         qCWarning(OkularUiDebug) << "viewport for page" << vp.pageNumber << "has no matching item!";
         d->blockViewport = false;
         return;
     }
 #ifdef PAGEVIEW_DEBUG
     qCDebug(OkularUiDebug) << "document viewport changed";
 #endif
     // relayout in "Single Pages" mode or if a relayout is pending
     d->blockPixmapsRequest = true;
     if ( !Okular::Settings::viewContinuous() || d->dirtyLayout )
         slotRelayoutPages();
 
     // restore viewport center or use default {x-center,v-top} alignment
     const QRect & r = item->croppedGeometry();
     int newCenterX = r.left(),
         newCenterY = r.top();
     if ( vp.rePos.enabled )
     {
         if ( vp.rePos.pos == Okular::DocumentViewport::Center )
         {
             newCenterX += (int)( normClamp( vp.rePos.normalizedX, 0.5 ) * (double)r.width() );
             newCenterY += (int)( normClamp( vp.rePos.normalizedY, 0.0 ) * (double)r.height() );
         }
         else
         {
             // TopLeft
             newCenterX += (int)( normClamp( vp.rePos.normalizedX, 0.0 ) * (double)r.width() + viewport()->width() / 2 );
             newCenterY += (int)( normClamp( vp.rePos.normalizedY, 0.0 ) * (double)r.height() + viewport()->height() / 2 );
         }
     }
     else
     {
         newCenterX += r.width() / 2;
         newCenterY += viewport()->height() / 2 - 10;
     }
 
     // if smooth movement requested, setup parameters and start it
     if ( smoothMove )
     {
         d->viewportMoveActive = true;
         d->viewportMoveTime.start();
         d->viewportMoveDest.setX( newCenterX );
         d->viewportMoveDest.setY( newCenterY );
         if ( !d->viewportMoveTimer )
         {
             d->viewportMoveTimer = new QTimer( this );
             connect( d->viewportMoveTimer, &QTimer::timeout,
                      this, &PageView::slotMoveViewport );
         }
         d->viewportMoveTimer->start( 25 );
         verticalScrollBar()->setEnabled( false );
         horizontalScrollBar()->setEnabled( false );
     }
     else
         center( newCenterX, newCenterY );
     d->blockPixmapsRequest = false;
 
     // request visible pixmaps in the current viewport and recompute it
     slotRequestVisiblePixmaps();
 
     // enable setViewport calls
     d->blockViewport = false;
 
     if( viewport() )
     {
         viewport()->update();
     }
 
     // since the page has moved below cursor, update it
     updateCursor();
 }
 
 void PageView::notifyPageChanged( int pageNumber, int changedFlags )
 {
     // only handle pixmap / highlight changes notifies
     if ( changedFlags & DocumentObserver::Bookmark )
         return;
 
     if ( changedFlags & DocumentObserver::Annotations )
     {
         const QLinkedList< Okular::Annotation * > annots = d->document->page( pageNumber )->annotations();
         const QLinkedList< Okular::Annotation * >::ConstIterator annItEnd = annots.end();
         QHash< Okular::Annotation*, AnnotWindow * >::Iterator it = d->m_annowindows.begin();
         for ( ; it != d->m_annowindows.end(); )
         {
             QLinkedList< Okular::Annotation * >::ConstIterator annIt = qFind( annots, it.key() );
             if ( annIt != annItEnd )
             {
                 (*it)->reloadInfo();
                 ++it;
             }
             else
             {
                 AnnotWindow *w = *it;
                 it = d->m_annowindows.erase( it );
                 // Need to delete after removing from the list
                 // otherwise deleting will call slotAnnotationWindowDestroyed which will mess
                 // the list and the iterators
                 delete w;
             }
         }
 
         QLinkedList< Okular::Annotation * >::ConstIterator annIt = qFind( annots, d->mouseAnnotation->annotation() );
         if ( annIt == annItEnd )
         {
             d->mouseAnnotation->cancel();
         }
     }
 
     if ( changedFlags & DocumentObserver::BoundingBox )
     {
 #ifdef PAGEVIEW_DEBUG
         qCDebug(OkularUiDebug) << "BoundingBox change on page" << pageNumber;
 #endif
         slotRelayoutPages();
         slotRequestVisiblePixmaps(); // TODO: slotRelayoutPages() may have done this already!
         // Repaint the whole widget since layout may have changed
         viewport()->update();
         return;
     }
 
     // iterate over visible items: if page(pageNumber) is one of them, repaint it
     QLinkedList< PageViewItem * >::const_iterator iIt = d->visibleItems.constBegin(), iEnd = d->visibleItems.constEnd();
     for ( ; iIt != iEnd; ++iIt )
         if ( (*iIt)->pageNumber() == pageNumber && (*iIt)->isVisible() )
         {
             // update item's rectangle plus the little outline
             QRect expandedRect = (*iIt)->croppedGeometry();
             // a PageViewItem is placed in the global page layout,
             // while we need to map its position in the viewport coordinates
             // (to get the correct area to repaint)
             expandedRect.translate( -contentAreaPosition() );
             expandedRect.adjust( -1, -1, 3, 3 );
             viewport()->update( expandedRect );
 
             // if we were "zoom-dragging" do not overwrite the "zoom-drag" cursor
             if ( cursor().shape() != Qt::SizeVerCursor )
             {
                 // since the page has been regenerated below cursor, update it
                 updateCursor();
             }
             break;
         }
 }
 
 void PageView::notifyContentsCleared( int changedFlags )
 {
     // if pixmaps were cleared, re-ask them
     if ( changedFlags & DocumentObserver::Pixmap )
         QMetaObject::invokeMethod(this, "slotRequestVisiblePixmaps", Qt::QueuedConnection);
 }
 
 void PageView::notifyZoom( int factor )
 {
     if ( factor > 0 )
         updateZoom( ZoomIn );
     else
         updateZoom( ZoomOut );
 }
 
 bool PageView::canUnloadPixmap( int pageNumber ) const
 {
     if ( Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Low ||
          Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Normal )
     {
         // if the item is visible, forbid unloading
         QLinkedList< PageViewItem * >::const_iterator vIt = d->visibleItems.constBegin(), vEnd = d->visibleItems.constEnd();
         for ( ; vIt != vEnd; ++vIt )
             if ( (*vIt)->pageNumber() == pageNumber )
                 return false;
     }
     else
     {
         // forbid unloading of the visible items, and of the previous and next
         QLinkedList< PageViewItem * >::const_iterator vIt = d->visibleItems.constBegin(), vEnd = d->visibleItems.constEnd();
         for ( ; vIt != vEnd; ++vIt )
             if ( abs( (*vIt)->pageNumber() - pageNumber ) <= 1 )
                 return false;
     }
     // if hidden premit unloading
     return true;
 }
 
 void PageView::notifyCurrentPageChanged( int previous, int current )
 {
     if ( previous != -1 )
     {
         PageViewItem * item = d->items.at( previous );
         if ( item )
         {
             Q_FOREACH ( VideoWidget *videoWidget, item->videoWidgets() )
                 videoWidget->pageLeft();
         }
     }
 
     if ( current != -1 )
     {
         PageViewItem * item = d->items.at( current );
         if ( item )
         {
             Q_FOREACH ( VideoWidget *videoWidget, item->videoWidgets() )
                 videoWidget->pageEntered();
         }
 
         // update zoom text and factor if in a ZoomFit/* zoom mode
         if ( d->zoomMode != ZoomFixed )
             updateZoomText();
     }
 }
 
 //END DocumentObserver inherited methods
 
 //BEGIN View inherited methods
 bool PageView::supportsCapability( ViewCapability capability ) const
 {
     switch ( capability )
     {
         case Zoom:
         case ZoomModality:
             return true;
     }
     return false;
 }
 
 Okular::View::CapabilityFlags PageView::capabilityFlags( ViewCapability capability ) const
 {
     switch ( capability )
     {
         case Zoom:
         case ZoomModality:
             return CapabilityRead | CapabilityWrite | CapabilitySerializable;
     }
     return 0;
 }
 
 QVariant PageView::capability( ViewCapability capability ) const
 {
     switch ( capability )
     {
         case Zoom:
             return d->zoomFactor;
         case ZoomModality:
             return d->zoomMode;
     }
     return QVariant();
 }
 
 void PageView::setCapability( ViewCapability capability, const QVariant &option )
 {
     switch ( capability )
     {
         case Zoom:
         {
             bool ok = true;
             double factor = option.toDouble( &ok );
             if ( ok && factor > 0.0 )
             {
                 d->zoomFactor = static_cast< float >( factor );
                 updateZoom( ZoomRefreshCurrent );
             }
             break;
         }
         case ZoomModality:
         {
             bool ok = true;
             int mode = option.toInt( &ok );
             if ( ok )
             {
                 if ( mode >= 0 && mode < 3 )
                     updateZoom( (ZoomMode)mode );
             }
             break;
         }
     }
 }
 
 //END View inherited methods
 
 //BEGIN widget events
 bool PageView::event( QEvent * event )
 {
     if ( event->type() == QEvent::Gesture )
     {
         return gestureEvent(static_cast<QGestureEvent*>( event ));
     }
 
     // do not stop the event
     return QAbstractScrollArea::event( event );
 }
 
 
 bool PageView::gestureEvent( QGestureEvent * event )
 {
     QPinchGesture *pinch = static_cast<QPinchGesture*>(event->gesture(Qt::PinchGesture));
 
     if (pinch)
     {
         // Viewport zoom level at the moment where the pinch gesture starts.
         // The viewport zoom level _during_ the gesture will be this value
         // times the relative zoom reported by QGestureEvent.
         static qreal vanillaZoom = d->zoomFactor;
 
         if (pinch->state() == Qt::GestureStarted)
         {
             vanillaZoom = d->zoomFactor;
         }
 
         const QPinchGesture::ChangeFlags changeFlags = pinch->changeFlags();
 
         // Zoom
         if (pinch->changeFlags() & QPinchGesture::ScaleFactorChanged)
         {
             d->zoomFactor = vanillaZoom * pinch->totalScaleFactor();
 
             d->blockPixmapsRequest = true;
             updateZoom( ZoomRefreshCurrent );
             d->blockPixmapsRequest = false;
             viewport()->repaint();
         }
 
         // Count the number of 90-degree rotations we did since the start of the pinch gesture.
         // Otherwise a pinch turned to 90 degrees and held there will rotate the page again and again.
         static int rotations = 0;
 
         if (changeFlags & QPinchGesture::RotationAngleChanged)
         {
             // Rotation angle relative to the accumulated page rotations triggered by the current pinch
             // We actually turn at 80 degrees rather than at 90 degrees.  That's less strain on the hands.
             const qreal relativeAngle = pinch->rotationAngle() - rotations*90;
             if (relativeAngle > 80)
             {
                 slotRotateClockwise();
                 rotations++;
             }
             if (relativeAngle < -80)
             {
                 slotRotateCounterClockwise();
                 rotations--;
             }
         }
 
         if (pinch->state() == Qt::GestureFinished)
         {
             rotations = 0;
         }
 
         return true;
     }
 
     return false;
 }
 
 void PageView::paintEvent(QPaintEvent *pe)
 {
         const QPoint areaPos = contentAreaPosition();
         // create the rect into contents from the clipped screen rect
         QRect viewportRect = viewport()->rect();
         viewportRect.translate( areaPos );
         QRect contentsRect = pe->rect().translated( areaPos ).intersected( viewportRect );
         if ( !contentsRect.isValid() )
             return;
 
 #ifdef PAGEVIEW_DEBUG
         qCDebug(OkularUiDebug) << "paintevent" << contentsRect;
 #endif
 
         // create the screen painter. a pixel painted at contentsX,contentsY
         // appears to the top-left corner of the scrollview.
         QPainter screenPainter( viewport() );
         // translate to simulate the scrolled content widget
         screenPainter.translate( -areaPos );
 
         // selectionRect is the normalized mouse selection rect
         QRect selectionRect = d->mouseSelectionRect;
         if ( !selectionRect.isNull() )
             selectionRect = selectionRect.normalized();
         // selectionRectInternal without the border
         QRect selectionRectInternal = selectionRect;
         selectionRectInternal.adjust( 1, 1, -1, -1 );
         // color for blending
         QColor selBlendColor = (selectionRect.width() > 8 || selectionRect.height() > 8) ?
                             d->mouseSelectionColor : Qt::red;
 
         // subdivide region into rects
         const QVector<QRect> &allRects = pe->region().rects();
         uint numRects = allRects.count();
 
         // preprocess rects area to see if it worths or not using subdivision
         uint summedArea = 0;
         for ( uint i = 0; i < numRects; i++ )
         {
             const QRect & r = allRects[i];
             summedArea += r.width() * r.height();
         }
         // very elementary check: SUMj(Region[j].area) is less than boundingRect.area
         bool useSubdivision = summedArea < (0.6 * contentsRect.width() * contentsRect.height());
         if ( !useSubdivision )
             numRects = 1;
 
         // iterate over the rects (only one loop if not using subdivision)
         for ( uint i = 0; i < numRects; i++ )
         {
             if ( useSubdivision )
             {
                 // set 'contentsRect' to a part of the sub-divided region
                 contentsRect = allRects[i].translated( areaPos ).intersected( viewportRect );
                 if ( !contentsRect.isValid() )
                     continue;
             }
 #ifdef PAGEVIEW_DEBUG
             qCDebug(OkularUiDebug) << contentsRect;
 #endif
 
             // note: this check will take care of all things requiring alpha blending (not only selection)
             bool wantCompositing = !selectionRect.isNull() && contentsRect.intersects( selectionRect );
             // also alpha-blend when there is a table selection...
             wantCompositing |= !d->tableSelectionParts.isEmpty();
 
             if ( wantCompositing && Okular::Settings::enableCompositing() )
             {
                 // create pixmap and open a painter over it (contents{left,top} becomes pixmap {0,0})
                 QPixmap doubleBuffer( contentsRect.size() * devicePixelRatioF() );
                 doubleBuffer.setDevicePixelRatio(devicePixelRatioF());
                 QPainter pixmapPainter( &doubleBuffer );
 
                 pixmapPainter.translate( -contentsRect.left(), -contentsRect.top() );
 
                 // 1) Layer 0: paint items and clear bg on unpainted rects
                 drawDocumentOnPainter( contentsRect, &pixmapPainter );
                 // 2a) Layer 1a: paint (blend) transparent selection (rectangle)
                 if ( !selectionRect.isNull() && selectionRect.intersects( contentsRect ) &&
                     !selectionRectInternal.contains( contentsRect ) )
                 {
                     QRect blendRect = selectionRectInternal.intersected( contentsRect );
                     // skip rectangles covered by the selection's border
                     if ( blendRect.isValid() )
                     {
                         // grab current pixmap into a new one to colorize contents
                         QPixmap blendedPixmap( blendRect.width() * devicePixelRatioF(), blendRect.height() * devicePixelRatioF() );
                         blendedPixmap.setDevicePixelRatio(devicePixelRatioF());
                         QPainter p( &blendedPixmap );
                         p.drawPixmap( 0, 0, doubleBuffer,
                                     blendRect.left() - contentsRect.left(), blendRect.top() - contentsRect.top(),
                                     blendRect.width() * devicePixelRatioF(), blendRect.height() * devicePixelRatioF() );
 
                         QColor blCol = selBlendColor.dark( 140 );
                         blCol.setAlphaF( 0.2 );
                         p.fillRect( blendedPixmap.rect(), blCol );
                         p.end();
                         // copy the blended pixmap back to its place
                         pixmapPainter.drawPixmap( blendRect.left(), blendRect.top(), blendedPixmap );
                     }
                     // draw border (red if the selection is too small)
                     pixmapPainter.setPen( selBlendColor );
                     pixmapPainter.drawRect( selectionRect.adjusted( 0, 0, -1, -1 ) );
                 }
                 // 2b) Layer 1b: paint (blend) transparent selection (table)
                 foreach (const TableSelectionPart &tsp, d->tableSelectionParts) {
                     QRect selectionPartRect = tsp.rectInItem.geometry(tsp.item->uncroppedWidth(), tsp.item->uncroppedHeight());
                     selectionPartRect.translate( tsp.item->uncroppedGeometry().topLeft () );
                     QRect selectionPartRectInternal = selectionPartRect;
                     selectionPartRectInternal.adjust( 1, 1, -1, -1 );
                     if ( !selectionPartRect.isNull() && selectionPartRect.intersects( contentsRect ) &&
                         !selectionPartRectInternal.contains( contentsRect ) )
                     {
                         QRect blendRect = selectionPartRectInternal.intersected( contentsRect );
                         // skip rectangles covered by the selection's border
                         if ( blendRect.isValid() )
                         {
                             // grab current pixmap into a new one to colorize contents
                             QPixmap blendedPixmap( blendRect.width()  * devicePixelRatioF(), blendRect.height()  * devicePixelRatioF() );
                             blendedPixmap.setDevicePixelRatio(devicePixelRatioF());
                             QPainter p( &blendedPixmap );
                             p.drawPixmap( 0, 0, doubleBuffer,
                                         blendRect.left() - contentsRect.left(), blendRect.top() - contentsRect.top(),
                                         blendRect.width() * devicePixelRatioF(), blendRect.height() * devicePixelRatioF() );
 
                             QColor blCol = d->mouseSelectionColor.dark( 140 );
                             blCol.setAlphaF( 0.2 );
                             p.fillRect( blendedPixmap.rect(), blCol );
                             p.end();
                             // copy the blended pixmap back to its place
                             pixmapPainter.drawPixmap( blendRect.left(), blendRect.top(), blendedPixmap );
                         }
                         // draw border (red if the selection is too small)
                         pixmapPainter.setPen( d->mouseSelectionColor );
                         pixmapPainter.drawRect( selectionPartRect.adjusted( 0, 0, -1, -1 ) );
                     }
                 }
                 drawTableDividers( &pixmapPainter );
                 // 3a) Layer 1: give annotator painting control
                 if ( d->annotator && d->annotator->routePaints( contentsRect ) )
                     d->annotator->routePaint( &pixmapPainter, contentsRect );
                 // 3b) Layer 1: give mouseAnnotation painting control
                 d->mouseAnnotation->routePaint( &pixmapPainter, contentsRect );
 
                 // 4) Layer 2: overlays
                 if ( Okular::Settings::debugDrawBoundaries() )
                 {
                     pixmapPainter.setPen( Qt::blue );
                     pixmapPainter.drawRect( contentsRect );
                 }
 
                 // finish painting and draw contents
                 pixmapPainter.end();
                 screenPainter.drawPixmap( contentsRect.left(), contentsRect.top(), doubleBuffer );
             }
             else
             {
                 // 1) Layer 0: paint items and clear bg on unpainted rects
                 drawDocumentOnPainter( contentsRect, &screenPainter );
                 // 2a) Layer 1a: paint opaque selection (rectangle)
                 if ( !selectionRect.isNull() && selectionRect.intersects( contentsRect ) &&
                     !selectionRectInternal.contains( contentsRect ) )
                 {
                     screenPainter.setPen( palette().color( QPalette::Active, QPalette::Highlight ).dark(110) );
                     screenPainter.drawRect( selectionRect );
                 }
                 // 2b) Layer 1b: paint opaque selection (table)
                 foreach (const TableSelectionPart &tsp, d->tableSelectionParts) {
                     QRect selectionPartRect = tsp.rectInItem.geometry(tsp.item->uncroppedWidth(), tsp.item->uncroppedHeight());
                     selectionPartRect.translate( tsp.item->uncroppedGeometry().topLeft () );
                     QRect selectionPartRectInternal = selectionPartRect;
                     selectionPartRectInternal.adjust( 1, 1, -1, -1 );
                     if ( !selectionPartRect.isNull() && selectionPartRect.intersects( contentsRect ) &&
                         !selectionPartRectInternal.contains( contentsRect ) )
                     {
                         screenPainter.setPen( palette().color( QPalette::Active, QPalette::Highlight ).dark(110) );
                         screenPainter.drawRect( selectionPartRect );
                     }
                 }
                 drawTableDividers( &screenPainter );
                 // 3a) Layer 1: give annotator painting control
                 if ( d->annotator && d->annotator->routePaints( contentsRect ) )
                     d->annotator->routePaint( &screenPainter, contentsRect );
                 // 3b) Layer 1: give mouseAnnotation painting control
                 d->mouseAnnotation->routePaint( &screenPainter, contentsRect );
 
                 // 4) Layer 2: overlays
                 if ( Okular::Settings::debugDrawBoundaries() )
                 {
                     screenPainter.setPen( Qt::red );
                     screenPainter.drawRect( contentsRect );
                 }
             }
         }
 }
 
 void PageView::drawTableDividers(QPainter * screenPainter)
 {
         if (!d->tableSelectionParts.isEmpty()) {
             screenPainter->setPen( d->mouseSelectionColor.dark() );
             if (d->tableDividersGuessed) {
                 QPen p = screenPainter->pen();
                 p.setStyle( Qt::DashLine );
                 screenPainter->setPen( p );
             }
             foreach (const TableSelectionPart &tsp, d->tableSelectionParts) {
                 QRect selectionPartRect = tsp.rectInItem.geometry(tsp.item->uncroppedWidth(), tsp.item->uncroppedHeight());
                 selectionPartRect.translate( tsp.item->uncroppedGeometry().topLeft () );
                 QRect selectionPartRectInternal = selectionPartRect;
                 selectionPartRectInternal.adjust( 1, 1, -1, -1 );
                 foreach(double col, d->tableSelectionCols) {
                     if (col >= tsp.rectInSelection.left && col <= tsp.rectInSelection.right) {
                         col = (col - tsp.rectInSelection.left) / (tsp.rectInSelection.right - tsp.rectInSelection.left);
                         const int x =  selectionPartRect.left() + col * selectionPartRect.width() + 0.5;
                         screenPainter->drawLine(
                             x, selectionPartRectInternal.top(),
                             x, selectionPartRectInternal.top() + selectionPartRectInternal.height()
                         );
                     }
                 }
                 foreach(double row, d->tableSelectionRows) {
                     if (row >= tsp.rectInSelection.top && row <= tsp.rectInSelection.bottom) {
                         row = (row - tsp.rectInSelection.top) / (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
                         const int y =  selectionPartRect.top() + row * selectionPartRect.height() + 0.5;
                         screenPainter->drawLine(
                             selectionPartRectInternal.left(), y,
                             selectionPartRectInternal.left() + selectionPartRectInternal.width(), y
                         );
                     }
                 }
             }
         }
 }
 
 void PageView::resizeEvent( QResizeEvent *e )
 {
     if ( d->items.isEmpty() )
     {
         resizeContentArea( e->size() );
         return;
     }
 
     if ( ( d->zoomMode == ZoomFitWidth || d->zoomMode == ZoomFitAuto ) && !verticalScrollBar()->isVisible() && qAbs(e->oldSize().height() - e->size().height()) < verticalScrollBar()->width() && d->verticalScrollBarVisible )
     {
         // this saves us from infinite resizing loop because of scrollbars appearing and disappearing
         // see bug 160628 for more info
         // TODO looks are still a bit ugly because things are left uncentered
         // but better a bit ugly than unusable
         d->verticalScrollBarVisible = false;
         resizeContentArea( e->size() );
         return;
     }
     else if ( d->zoomMode == ZoomFitAuto && !horizontalScrollBar()->isVisible() && qAbs(e->oldSize().width() - e->size().width()) < horizontalScrollBar()->height() && d->horizontalScrollBarVisible )
     {
         // this saves us from infinite resizing loop because of scrollbars appearing and disappearing
         // TODO looks are still a bit ugly because things are left uncentered
         // but better a bit ugly than unusable
         d->horizontalScrollBarVisible = false;
         resizeContentArea( e->size() );
         return;
     }
 
     // start a timer that will refresh the pixmap after 0.2s
     d->delayResizeEventTimer->start( 200 );
     d->verticalScrollBarVisible = verticalScrollBar()->isVisible();
     d->horizontalScrollBarVisible = horizontalScrollBar()->isVisible();
 }
 
 void PageView::keyPressEvent( QKeyEvent * e )
 {
     e->accept();
 
     // if performing a selection or dyn zooming, disable keys handling
     if ( ( d->mouseSelecting && e->key() != Qt::Key_Escape ) || ( QApplication::mouseButtons () & Qt::MidButton ) )
         return;
 
     // if viewport is moving, disable keys handling
     if ( d->viewportMoveActive )
         return;
 
     // move/scroll page by using keys
     switch ( e->key() )
     {
         case Qt::Key_J:
         case Qt::Key_K:
         case Qt::Key_Down:
         case Qt::Key_PageDown:
         case Qt::Key_Up:
         case Qt::Key_PageUp:
         case Qt::Key_Backspace:
             if ( e->key() == Qt::Key_Down
                  || e->key() == Qt::Key_PageDown
                  || e->key() == Qt::Key_J )
             {
                 bool singleStep = e->key() == Qt::Key_Down || e->key() == Qt::Key_J;
                 slotScrollDown( singleStep );
             }
             else
             {
                 bool singleStep = e->key() == Qt::Key_Up || e->key() == Qt::Key_K;
                 slotScrollUp( singleStep );
             }
             break;
         case Qt::Key_Left:
         case Qt::Key_H:
             if ( horizontalScrollBar()->maximum() == 0 )
             {
                 //if we cannot scroll we go to the previous page vertically
                 int next_page = d->document->currentPage() - viewColumns();
                 d->document->setViewportPage(next_page);
             }
             else
                 horizontalScrollBar()->triggerAction( QScrollBar::SliderSingleStepSub );
             break;
         case Qt::Key_Right:
         case Qt::Key_L:
             if ( horizontalScrollBar()->maximum() == 0 )
             {
                 //if we cannot scroll we advance the page vertically
                 int next_page = d->document->currentPage() + viewColumns();
                 d->document->setViewportPage(next_page);
             }
             else
                 horizontalScrollBar()->triggerAction( QScrollBar::SliderSingleStepAdd );
             break;
         case Qt::Key_Escape:
             emit escPressed();
             selectionClear( d->tableDividersGuessed ? ClearOnlyDividers : ClearAllSelection );
             d->mousePressPos = QPoint();
             if ( d->aPrevAction )
             {
                 d->aPrevAction->trigger();
                 d->aPrevAction = 0;
             }
             d->mouseAnnotation->routeKeyPressEvent( e );
             break;
         case Qt::Key_Delete:
             d->mouseAnnotation->routeKeyPressEvent( e );
             break;
         case Qt::Key_Shift:
         case Qt::Key_Control:
             if ( d->autoScrollTimer )
             {
                 if ( d->autoScrollTimer->isActive() )
                     d->autoScrollTimer->stop();
                 else
                     slotAutoScroll();
                 return;
             }
             // else fall trhough
         default:
             e->ignore();
             return;
     }
     // if a known key has been pressed, stop scrolling the page
     if ( d->autoScrollTimer )
     {
         d->scrollIncrement = 0;
         d->autoScrollTimer->stop();
     }
 }
 
 void PageView::keyReleaseEvent( QKeyEvent * e )
 {
     e->accept();
 
     if ( d->annotator && d->annotator->active() )
     {
         if ( d->annotator->routeKeyEvent( e ) )
             return;
     }
 
     if ( e->key() == Qt::Key_Escape && d->autoScrollTimer )
     {
         d->scrollIncrement = 0;
         d->autoScrollTimer->stop();
     }
 }
 
 void PageView::inputMethodEvent( QInputMethodEvent * e )
 {
     Q_UNUSED(e)
 }
 
 void PageView::tabletEvent( QTabletEvent * e )
 {
     // Ignore tablet events that we don't care about
     if ( !( e->type() == QEvent::TabletPress ||
             e->type() == QEvent::TabletRelease ||
             e->type() == QEvent::TabletMove ) )
     {
         e->ignore();
         return;
     }
 
     // Determine pen state
     bool penReleased = false;
     if ( e->type() == QEvent::TabletPress )
     {
         d->penDown = true;
     }
     if ( e->type() == QEvent::TabletRelease )
     {
         d->penDown = false;
         penReleased = true;
     }
 
     // If we're editing an annotation and the tablet pen is either down or just released
     // then dispatch event to annotator
     if ( d->annotator && d->annotator->active() && ( d->penDown || penReleased ) )
     {
         const QPoint eventPos = contentAreaPoint( e->pos() );
         PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
         const QPoint localOriginInGlobal = mapToGlobal( QPoint(0,0) );
 
         // routeTabletEvent will accept or ignore event as appropriate
         d->annotator->routeTabletEvent( e, pageItem, localOriginInGlobal );
     } else {
         e->ignore();
     }
 }
 
 void PageView::mouseMoveEvent( QMouseEvent * e )
 {
     d->controlWheelAccumulatedDelta = 0;
 
     // don't perform any mouse action when no document is shown
     if ( d->items.isEmpty() )
         return;
 
     // don't perform any mouse action when viewport is autoscrolling
     if ( d->viewportMoveActive )
         return;
 
     // if holding mouse mid button, perform zoom
     if ( e->buttons() & Qt::MidButton )
     {
         int mouseY = e->globalPos().y();
         int deltaY = d->mouseMidLastY - mouseY;
 
         // wrap mouse from top to bottom
         const QRect mouseContainer = QApplication::desktop()->screenGeometry( this );
         const int absDeltaY = abs(deltaY);
         if ( absDeltaY > mouseContainer.height() / 2 )
         {
             deltaY = mouseContainer.height() - absDeltaY;
         }
 
         const float upperZoomLimit = d->document->supportsTiles() ? 15.99 : 3.99;
         if ( mouseY <= mouseContainer.top() + 4 &&
              d->zoomFactor < upperZoomLimit )
         {
             mouseY = mouseContainer.bottom() - 5;
             QCursor::setPos( e->globalPos().x(), mouseY );
         }
         // wrap mouse from bottom to top
         else if ( mouseY >= mouseContainer.bottom() - 4 &&
                   d->zoomFactor > 0.101 )
         {
             mouseY = mouseContainer.top() + 5;
             QCursor::setPos( e->globalPos().x(), mouseY );
         }
         // remember last position
         d->mouseMidLastY = mouseY;
 
         // update zoom level, perform zoom and redraw
         if ( deltaY )
         {
             d->zoomFactor *= ( 1.0 + ( (double)deltaY / 500.0 ) );
             d->blockPixmapsRequest = true;
             updateZoom( ZoomRefreshCurrent );
             d->blockPixmapsRequest = false;
             viewport()->repaint();
         }
         return;
     }
 
     const QPoint eventPos = contentAreaPoint( e->pos() );
 
     // if we're editing an annotation, dispatch event to it
     if ( d->annotator && d->annotator->active() )
     {
         PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
         updateCursor( eventPos );
         d->annotator->routeMouseEvent( e, pageItem );
         return;
     }
 
     bool leftButton = (e->buttons() == Qt::LeftButton);
     bool rightButton = (e->buttons() == Qt::RightButton);
 
     switch ( d->mouseMode )
     {
         case Okular::Settings::EnumMouseMode::Browse:
         {
             PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
             if ( leftButton )
             {
                 d->leftClickTimer.stop();
                 if ( pageItem && d->mouseAnnotation->isActive() )
                 {
                     // if left button pressed and annotation is focused, forward move event
                     d->mouseAnnotation->routeMouseMoveEvent( pageItem, eventPos, leftButton );
                 }
                 // drag page
                 else if ( !d->mouseGrabPos.isNull() )
                 {
                     setCursor( Qt::ClosedHandCursor );
 
                     QPoint mousePos = e->globalPos();
                     QPoint delta = d->mouseGrabPos - mousePos;
 
                     // wrap mouse from top to bottom
                     const QRect mouseContainer = QApplication::desktop()->screenGeometry( this );
                     // If the delta is huge it probably means we just wrapped in that direction
                     const QPoint absDelta(abs(delta.x()), abs(delta.y()));
                     if ( absDelta.y() > mouseContainer.height() / 2 )
                     {
                         delta.setY(mouseContainer.height() - absDelta.y());
                     }
                     if ( absDelta.x() > mouseContainer.width() / 2 )
                     {
                         delta.setX(mouseContainer.width() - absDelta.x());
                     }
                     if ( mousePos.y() <= mouseContainer.top() + 4 &&
                          verticalScrollBar()->value() < verticalScrollBar()->maximum() - 10 )
                     {
                         mousePos.setY( mouseContainer.bottom() - 5 );
                         QCursor::setPos( mousePos );
                     }
                     // wrap mouse from bottom to top
                     else if ( mousePos.y() >= mouseContainer.bottom() - 4 &&
                               verticalScrollBar()->value() > 10 )
                     {
                         mousePos.setY( mouseContainer.top() + 5 );
                         QCursor::setPos( mousePos );
                     }
                     // remember last position
                     d->mouseGrabPos = mousePos;
 
                     // scroll page by position increment
                     scrollTo( horizontalScrollBar()->value() + delta.x(), verticalScrollBar()->value() + delta.y() );
                 }
             }
             else if ( rightButton && !d->mousePressPos.isNull() && d->aMouseSelect )
             {
                 // if mouse moves 5 px away from the press point, switch to 'selection'
                 int deltaX = d->mousePressPos.x() - e->globalPos().x(),
                     deltaY = d->mousePressPos.y() - e->globalPos().y();
                 if ( deltaX > 5 || deltaX < -5 || deltaY > 5 || deltaY < -5 )
                 {
                     d->aPrevAction = d->aMouseNormal;
                     d->aMouseSelect->trigger();
                     QPoint newPos = eventPos + QPoint( deltaX, deltaY );
                     selectionStart( newPos, palette().color( QPalette::Active, QPalette::Highlight ).light( 120 ), false );
                     updateSelection( eventPos );
                     break;
                 }
             }
             else
             {
                 /* Forward move events which are still not yet consumed by "mouse grab" or aMouseSelect */
                 d->mouseAnnotation->routeMouseMoveEvent( pageItem, eventPos, leftButton );
                 updateCursor();
             }
         }
         break;
 
         case Okular::Settings::EnumMouseMode::Zoom:
         case Okular::Settings::EnumMouseMode::RectSelect:
         case Okular::Settings::EnumMouseMode::TableSelect:
         case Okular::Settings::EnumMouseMode::TrimSelect:
             // set second corner of selection
             if ( d->mouseSelecting )
                 updateSelection( eventPos );
             break;
 
         case Okular::Settings::EnumMouseMode::Magnifier:
             if ( e->buttons() ) // if any button is pressed at all
             {
                 moveMagnifier( e->pos() );
                 updateMagnifier( eventPos );
             }
             break;
 
         case Okular::Settings::EnumMouseMode::TextSelect:
             // if mouse moves 5 px away from the press point and the document soupports text extraction, do 'textselection'
             if ( !d->mouseTextSelecting && !d->mousePressPos.isNull() && d->document->supportsSearching() && ( ( eventPos - d->mouseSelectPos ).manhattanLength() > 5 ) )
             {
                 d->mouseTextSelecting = true;
             }
             updateSelection( eventPos );
             updateCursor();
             break;
     }
 }
 
 void PageView::mousePressEvent( QMouseEvent * e )
 {
     d->controlWheelAccumulatedDelta = 0;
 
     // don't perform any mouse action when no document is shown
     if ( d->items.isEmpty() )
         return;
 
     // if performing a selection or dyn zooming, disable mouse press
     if ( d->mouseSelecting || ( e->button() != Qt::MidButton && ( e->buttons() & Qt::MidButton) ) || d->viewportMoveActive )
         return;
 
     // if the page is scrolling, stop it
     if ( d->autoScrollTimer )
     {
         d->scrollIncrement = 0;
         d->autoScrollTimer->stop();
     }
 
     // if pressing mid mouse button while not doing other things, begin 'continuous zoom' mode
     if ( e->button() == Qt::MidButton )
     {
         d->mouseMidLastY = e->globalPos().y();
         setCursor( Qt::SizeVerCursor );
         return;
     }
 
     const QPoint eventPos = contentAreaPoint( e->pos() );
 
     // if we're editing an annotation, dispatch event to it
     if ( d->annotator && d->annotator->active() )
     {
         PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
         d->annotator->routeMouseEvent( e, pageItem );
         return;
     }
 
     // trigger history navigation for additional mouse buttons
     if ( e->button() == Qt::XButton1 )
     {
         emit mouseBackButtonClick();
         return;
     }
     if ( e->button() == Qt::XButton2 )
     {
         emit mouseForwardButtonClick();
         return;
     }
 
     // update press / 'start drag' mouse position
     d->mousePressPos = e->globalPos();
 
     // handle mode dependant mouse press actions
     bool leftButton = e->button() == Qt::LeftButton,
          rightButton = e->button() == Qt::RightButton;
 
 //   Not sure we should erase the selection when clicking with left.
      if ( d->mouseMode != Okular::Settings::EnumMouseMode::TextSelect )
        textSelectionClear();
 
     switch ( d->mouseMode )
     {
         case Okular::Settings::EnumMouseMode::Browse:   // drag start / click / link following
         {
             PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
             if ( leftButton )
             {
                 if ( pageItem )
                 {
                     d->mouseAnnotation->routeMousePressEvent( pageItem, eventPos );
                 }
                 d->mouseGrabPos = d->mouseOnRect ? QPoint() : d->mousePressPos;
                 if ( !d->mouseOnRect )
                     d->leftClickTimer.start( QApplication::doubleClickInterval() + 10 );
             }
             else if ( rightButton )
             {
                 if ( pageItem )
                 {
                     // find out normalized mouse coords inside current item
                     const QRect & itemRect = pageItem->uncroppedGeometry();
                     double nX = pageItem->absToPageX(eventPos.x());
                     double nY = pageItem->absToPageY(eventPos.y());
 
                     const QLinkedList< const Okular::ObjectRect *> orects = pageItem->page()->objectRects( Okular::ObjectRect::OAnnotation, nX, nY, itemRect.width(), itemRect.height() );
 
                     if ( !orects.isEmpty() )
                     {
                         AnnotationPopup popup( d->document, AnnotationPopup::MultiAnnotationMode, this );
 
                         foreach ( const Okular::ObjectRect * orect, orects )
                         {
                             Okular::Annotation * ann = ( (Okular::AnnotationObjectRect *)orect )->annotation();
                             if ( ann && (ann->subType() != Okular::Annotation::AWidget) )
                                 popup.addAnnotation( ann, pageItem->pageNumber() );
 
                         }
 
                         connect( &popup, &AnnotationPopup::openAnnotationWindow,
                                  this, &PageView::openAnnotationWindow );
 
                         popup.exec( e->globalPos() );
                         // Since ↑ spins its own event loop we won't get the mouse release event
                         // so reset mousePressPos here
                         d->mousePressPos = QPoint();
                     }
                 }
             }
         }
         break;
 
         case Okular::Settings::EnumMouseMode::Zoom:     // set first corner of the zoom rect
             if ( leftButton )
                 selectionStart( eventPos, palette().color( QPalette::Active, QPalette::Highlight ), false );
             else if ( rightButton )
                 updateZoom( ZoomOut );
             break;
 
         case Okular::Settings::EnumMouseMode::Magnifier:
             moveMagnifier( e->pos() );
             d->magnifierView->show();
             updateMagnifier( eventPos );
             break;
 
         case Okular::Settings::EnumMouseMode::RectSelect:   // set first corner of the selection rect
         case Okular::Settings::EnumMouseMode::TrimSelect:
              if ( leftButton )
              {
                 selectionStart( eventPos, palette().color( QPalette::Active, QPalette::Highlight ).light( 120 ), false );
              }
             break;
         case Okular::Settings::EnumMouseMode::TableSelect:
              if ( leftButton )
              {
                 if (d->tableSelectionParts.isEmpty())
                 {
                     selectionStart( eventPos, palette().color( QPalette::Active, QPalette::Highlight ).light( 120 ), false );
                 } else {
                     QRect updatedRect;
                     foreach (const TableSelectionPart &tsp, d->tableSelectionParts) {
                         QRect selectionPartRect = tsp.rectInItem.geometry(tsp.item->uncroppedWidth(), tsp.item->uncroppedHeight());
                         selectionPartRect.translate( tsp.item->uncroppedGeometry().topLeft () );
 
                         // This will update the whole table rather than just the added/removed divider
                         // (which can span more than one part).
                         updatedRect = updatedRect.united(selectionPartRect);
 
                         if (!selectionPartRect.contains(eventPos))
                             continue;
 
                         // At this point it's clear we're either adding or removing a divider manually, so obviously the user is happy with the guess (if any).
                         d->tableDividersGuessed = false;
 
                         // There's probably a neat trick to finding which edge it's closest to,
                         // but this way has the advantage of simplicity.
                         const int fromLeft = abs(selectionPartRect.left() - eventPos.x());
                         const int fromRight = abs(selectionPartRect.left() + selectionPartRect.width() - eventPos.x());
                         const int fromTop = abs(selectionPartRect.top() - eventPos.y());
                         const int fromBottom = abs(selectionPartRect.top() + selectionPartRect.height() - eventPos.y());
                         const int colScore = fromTop<fromBottom ? fromTop : fromBottom;
                         const int rowScore = fromLeft<fromRight ? fromLeft : fromRight;
 
                         if (colScore < rowScore) {
                             bool deleted=false;
                             for(int i=0; i<d->tableSelectionCols.length(); i++) {
                                 const double col = (d->tableSelectionCols[i] - tsp.rectInSelection.left) / (tsp.rectInSelection.right - tsp.rectInSelection.left);
                                 const int colX =  selectionPartRect.left() + col * selectionPartRect.width() + 0.5;
                                 if (abs(colX - eventPos.x())<=3) {
                                     d->tableSelectionCols.removeAt(i);
                                     deleted=true;
 
                                     break;
                                 }
                             }
                             if (!deleted) {
                                 double col = eventPos.x() - selectionPartRect.left();
                                 col /= selectionPartRect.width(); // at this point, it's normalised within the part
                                 col *= (tsp.rectInSelection.right - tsp.rectInSelection.left);
                                 col += tsp.rectInSelection.left; // at this point, it's normalised within the whole table
 
                                 d->tableSelectionCols.append(col);
                                 qSort(d->tableSelectionCols);
                             }
                         } else {
                             bool deleted=false;
                             for(int i=0; i<d->tableSelectionRows.length(); i++) {
                                 const double row = (d->tableSelectionRows[i] - tsp.rectInSelection.top) / (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
                                 const int rowY =  selectionPartRect.top() + row * selectionPartRect.height() + 0.5;
                                 if (abs(rowY - eventPos.y())<=3) {
                                     d->tableSelectionRows.removeAt(i);
                                     deleted=true;
 
                                     break;
                                 }
                             }
                             if (!deleted) {
                                 double row = eventPos.y() - selectionPartRect.top();
                                 row /= selectionPartRect.height(); // at this point, it's normalised within the part
                                 row *= (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
                                 row += tsp.rectInSelection.top; // at this point, it's normalised within the whole table
 
                                 d->tableSelectionRows.append(row);
                                 qSort(d->tableSelectionRows);
                             }
                         }
                     }
                     updatedRect.translate( -contentAreaPosition() );
                     viewport()->update( updatedRect );
                 }
              }
             break;
         case Okular::Settings::EnumMouseMode::TextSelect:
             d->mouseSelectPos = eventPos;
             if ( !rightButton )
             {
                 textSelectionClear();
             }
             break;
     }
 }
 
 void PageView::mouseReleaseEvent( QMouseEvent * e )
 {
     d->controlWheelAccumulatedDelta = 0;
 
     // stop the drag scrolling
     d->dragScrollTimer.stop();
 
     d->leftClickTimer.stop();
 
     const bool leftButton = e->button() == Qt::LeftButton;
     const bool rightButton = e->button() == Qt::RightButton;
 
     if ( d->mouseAnnotation->isActive() && leftButton )
     {
         // Just finished to move the annotation
         d->mouseAnnotation->routeMouseReleaseEvent();
     }
 
     // don't perform any mouse action when no document is shown..
     if ( d->items.isEmpty() )
     {
         // ..except for right Clicks (emitted even it viewport is empty)
         if ( e->button() == Qt::RightButton )
             emit rightClick( 0, e->globalPos() );
         return;
     }
 
     // don't perform any mouse action when viewport is autoscrolling
     if ( d->viewportMoveActive )
         return;
 
     const QPoint eventPos = contentAreaPoint( e->pos() );
 
     // handle mode indepent mid buttom zoom
     if ( e->button() == Qt::MidButton )
     {
         // request pixmaps since it was disabled during drag
         slotRequestVisiblePixmaps();
         // the cursor may now be over a link.. update it
         updateCursor( eventPos );
         return;
     }
 
     // if we're editing an annotation, dispatch event to it
     if ( d->annotator && d->annotator->active() )
     {
         PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
         d->annotator->routeMouseEvent( e, pageItem );
         return;
     }
 
     switch ( d->mouseMode )
     {
         case Okular::Settings::EnumMouseMode::Browse:{
             // return the cursor to its normal state after dragging
             if ( cursor().shape() == Qt::ClosedHandCursor )
                 updateCursor( eventPos );
 
             PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
             const QPoint pressPos = contentAreaPoint( mapFromGlobal( d->mousePressPos ) );
             const PageViewItem * pageItemPressPos = pickItemOnPoint( pressPos.x(), pressPos.y() );
 
             // if the mouse has not moved since the press, that's a -click-
             if ( leftButton && pageItem && pageItem == pageItemPressPos &&
                  ( (d->mousePressPos - e->globalPos()).manhattanLength() < QApplication::startDragDistance() ) )
             {
                 double nX = pageItem->absToPageX(eventPos.x());
                 double nY = pageItem->absToPageY(eventPos.y());
                 const Okular::ObjectRect * rect;
                 rect = pageItem->page()->objectRect( Okular::ObjectRect::Action, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                 if ( rect )
                 {
                     // handle click over a link
                     const Okular::Action * action = static_cast< const Okular::Action * >( rect->object() );
                     d->document->processAction( action );
                 }
                 else if ( e->modifiers() == Qt::ShiftModifier )
                 {
                     // TODO: find a better way to activate the source reference "links"
                     // for the moment they are activated with Shift + left click
                     // Search the nearest source reference.
                     rect = pageItem->page()->objectRect( Okular::ObjectRect::SourceRef, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                     if ( !rect )
                     {
                         static const double s_minDistance = 0.025; // FIXME?: empirical value?
                         double distance = 0.0;
                         rect = pageItem->page()->nearestObjectRect( Okular::ObjectRect::SourceRef, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight(), &distance );
                         // distance is distanceSqr, adapt it to a normalized value
                         distance = distance / (pow( pageItem->uncroppedWidth(), 2 ) + pow( pageItem->uncroppedHeight(), 2 ));
                         if ( rect && ( distance > s_minDistance ) )
                             rect = 0;
                     }
                     if ( rect )
                     {
                         const Okular::SourceReference * ref = static_cast< const Okular::SourceReference * >( rect->object() );
                         d->document->processSourceReference( ref );
                     }
                     else
                     {
                         const Okular::SourceReference * ref = d->document->dynamicSourceReference( pageItem->  pageNumber(), nX * pageItem->page()->width(), nY * pageItem->page()->height() );
                         if ( ref )
                         {
                             d->document->processSourceReference( ref );
                             delete ref;
                         }
                     }
                 }
 #if 0
                 else
                 {
                     // a link can move us to another page or even to another document, there's no point in trying to
                     //  process the click on the image once we have processes the click on the link
                     rect = pageItem->page()->objectRect( Okular::ObjectRect::Image, nX, nY, pageItem->width(), pageItem->height() );
                     if ( rect )
                     {
                         // handle click over a image
                     }
 /*		Enrico and me have decided this is not worth the trouble it generates
                     else
                     {
                         // if not on a rect, the click selects the page
                         // if ( pageItem->pageNumber() != (int)d->document->currentPage() )
                         d->document->setViewportPage( pageItem->pageNumber(), this );
                     }*/
                 }
 #endif
             }
             else if ( rightButton && !d->mouseAnnotation->isModified() )
             {
                 if ( pageItem && pageItem == pageItemPressPos &&
                      ( (d->mousePressPos - e->globalPos()).manhattanLength() < QApplication::startDragDistance() ) )
                 {
                     double nX = pageItem->absToPageX(eventPos.x());
                     double nY = pageItem->absToPageY(eventPos.y());
                     const Okular::ObjectRect * rect;
                     rect = pageItem->page()->objectRect( Okular::ObjectRect::Action, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                     if ( rect )
                     {
                         // handle right click over a link
                         const Okular::Action * link = static_cast< const Okular::Action * >( rect->object() );
                         // creating the menu and its actions
                         QMenu menu( this );
                         QAction * actProcessLink = menu.addAction( i18n( "Follow This Link" ) );
                         QAction * actStopSound = 0;
                         if ( link->actionType() == Okular::Action::Sound ) {
                             actProcessLink->setText( i18n( "Play this Sound" ) );
                             if ( Okular::AudioPlayer::instance()->state() == Okular::AudioPlayer::PlayingState ) {
                                 actStopSound = menu.addAction( i18n( "Stop Sound" ) );
                             }
                         }
                         QAction * actCopyLinkLocation = 0;
                         if ( dynamic_cast< const Okular::BrowseAction * >( link ) )
                             actCopyLinkLocation = menu.addAction( QIcon::fromTheme( QStringLiteral("edit-copy") ), i18n( "Copy Link Address" ) );
                         QAction * res = menu.exec( e->globalPos() );
                         if ( res )
                         {
                             if ( res == actProcessLink )
                             {
                                 d->document->processAction( link );
                             }
                             else if ( res == actCopyLinkLocation )
                             {
                                 const Okular::BrowseAction * browseLink = static_cast< const Okular::BrowseAction * >( link );
                                 QClipboard *cb = QApplication::clipboard();
                                 cb->setText( browseLink->url().toDisplayString(), QClipboard::Clipboard );
                                 if ( cb->supportsSelection() )
                                     cb->setText( browseLink->url().toDisplayString(), QClipboard::Selection );
                             }
                             else if ( res == actStopSound )
                             {
                                 Okular::AudioPlayer::instance()->stopPlaybacks();
                             }
                         }
                     }
                     else
                     {
                         // a link can move us to another page or even to another document, there's no point in trying to
                         //  process the click on the image once we have processes the click on the link
                         rect = pageItem->page()->objectRect( Okular::ObjectRect::Image, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                         if ( rect )
                         {
                             // handle right click over a image
                         }
                         else
                         {
                             // right click (if not within 5 px of the press point, the mode
                             // had been already changed to 'Selection' instead of 'Normal')
                             emit rightClick( pageItem->page(), e->globalPos() );
                         }
                     }
                 }
                 else
                 {
                     // right click (if not within 5 px of the press point, the mode
                     // had been already changed to 'Selection' instead of 'Normal')
                     emit rightClick( pageItem ? pageItem->page() : 0, e->globalPos() );
                 }
             }
             }break;
 
         case Okular::Settings::EnumMouseMode::Zoom:
             // if a selection rect has been defined, zoom into it
             if ( leftButton && d->mouseSelecting )
             {
                 QRect selRect = d->mouseSelectionRect.normalized();
                 if ( selRect.width() <= 8 && selRect.height() <= 8 )
                 {
                     selectionClear();
                     break;
                 }
 
                 // find out new zoom ratio and normalized view center (relative to the contentsRect)
                 double zoom = qMin( (double)viewport()->width() / (double)selRect.width(), (double)viewport()->height() / (double)selRect.height() );
                 double nX = (double)(selRect.left() + selRect.right()) / (2.0 * (double)contentAreaWidth());
                 double nY = (double)(selRect.top() + selRect.bottom()) / (2.0 * (double)contentAreaHeight());
 
                 const float upperZoomLimit = d->document->supportsTiles() ? 16.0 : 4.0;
                 if ( d->zoomFactor <= upperZoomLimit || zoom <= 1.0 )
                 {
                     d->zoomFactor *= zoom;
                     viewport()->setUpdatesEnabled( false );
                     updateZoom( ZoomRefreshCurrent );
                     viewport()->setUpdatesEnabled( true );
                 }
 
                 // recenter view and update the viewport
                 center( (int)(nX * contentAreaWidth()), (int)(nY * contentAreaHeight()) );
                 viewport()->update();
 
                 // hide message box and delete overlay window
                 selectionClear();
             }
             break;
 
         case Okular::Settings::EnumMouseMode::Magnifier:
             d->magnifierView->hide();
             break;
 
         case Okular::Settings::EnumMouseMode::TrimSelect:
         {
             // if mouse is released and selection is null this is a rightClick
             if ( rightButton && !d->mouseSelecting )
             {
                 break;
             }
             PageViewItem * pageItem = pickItemOnPoint(eventPos.x(), eventPos.y());
             // ensure end point rests within a page, or ignore
             if (!pageItem) {
                 break;
             }
             QRect selectionRect = d->mouseSelectionRect.normalized();
 
             double nLeft = pageItem->absToPageX(selectionRect.left());
             double nRight = pageItem->absToPageX(selectionRect.right());
             double nTop = pageItem->absToPageY(selectionRect.top());
             double nBottom = pageItem->absToPageY(selectionRect.bottom());
             if ( nLeft < 0 ) nLeft = 0;
             if ( nTop < 0 ) nTop = 0;
             if ( nRight > 1 ) nRight = 1;
             if ( nBottom > 1 ) nBottom = 1;
             d->trimBoundingBox = Okular::NormalizedRect(nLeft, nTop, nRight, nBottom);
 
             // Trim Selection successfully done, hide prompt
             d->messageWindow->hide();
 
             // clear widget selection and invalidate rect
             selectionClear();
 
             // When Trim selection bbox interaction is over, we should switch to another mousemode.
             if ( d->aPrevAction )
             {
                 d->aPrevAction->trigger();
                 d->aPrevAction = 0;
             } else {
                 d->aMouseNormal->trigger();
             }
 
             // with d->trimBoundingBox defined, redraw for trim to take visual effect
             if ( d->document->pages() > 0 )
             {
                 slotRelayoutPages();
                 slotRequestVisiblePixmaps();  // TODO: slotRelayoutPages() may have done this already!
             }
 
             break;
         }
         case Okular::Settings::EnumMouseMode::RectSelect:
         {
             // if mouse is released and selection is null this is a rightClick
             if ( rightButton && !d->mouseSelecting )
             {
                 PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
                 emit rightClick( pageItem ? pageItem->page() : 0, e->globalPos() );
                 break;
             }
 
             // if a selection is defined, display a popup
             if ( (!leftButton && !d->aPrevAction) || (!rightButton && d->aPrevAction) ||
                  !d->mouseSelecting )
                 break;
 
             QRect selectionRect = d->mouseSelectionRect.normalized();
             if ( selectionRect.width() <= 8 && selectionRect.height() <= 8 )
             {
                 selectionClear();
                 if ( d->aPrevAction )
                 {
                     d->aPrevAction->trigger();
                     d->aPrevAction = 0;
                 }
                 break;
             }
 
             // if we support text generation
             QString selectedText;
             if (d->document->supportsSearching())
             {
                 // grab text in selection by extracting it from all intersected pages
                 const Okular::Page * okularPage=0;
                 QVector< PageViewItem * >::const_iterator iIt = d->items.constBegin(), iEnd = d->items.constEnd();
                 for ( ; iIt != iEnd; ++iIt )
                 {
                     PageViewItem * item = *iIt;
                     if ( !item->isVisible() )
                         continue;
 
                     const QRect & itemRect = item->croppedGeometry();
                     if ( selectionRect.intersects( itemRect ) )
                     {
                         // request the textpage if there isn't one
                         okularPage= item->page();
                         qCDebug(OkularUiDebug) << "checking if page" << item->pageNumber() << "has text:" << okularPage->hasTextPage();
                         if ( !okularPage->hasTextPage() )
                             d->document->requestTextPage( okularPage->number() );
                         // grab text in the rect that intersects itemRect
                         QRect relativeRect = selectionRect.intersected( itemRect );
                         relativeRect.translate( -item->uncroppedGeometry().topLeft() );
                         Okular::RegularAreaRect rects;
                         rects.append( Okular::NormalizedRect( relativeRect, item->uncroppedWidth(), item->uncroppedHeight() ) );
                         selectedText += okularPage->text( &rects );
                     }
                 }
             }
 
             // popup that ask to copy:text and copy/save:image
             QMenu menu( this );
             QAction *textToClipboard = 0;
 #ifdef HAVE_SPEECH
             QAction *speakText = 0;
 #endif
             QAction *imageToClipboard = 0;
             QAction *imageToFile = 0;
             if ( d->document->supportsSearching() && !selectedText.isEmpty() )
             {
                 menu.addAction( new OKMenuTitle( &menu, i18np( "Text (1 character)", "Text (%1 characters)", selectedText.length() ) ) );
                 textToClipboard = menu.addAction( QIcon::fromTheme(QStringLiteral("edit-copy")), i18n( "Copy to Clipboard" ) );
                 bool copyAllowed = d->document->isAllowed( Okular::AllowCopy );
                 if ( !copyAllowed )
                 {
                     textToClipboard->setEnabled( false );
                     textToClipboard->setText( i18n("Copy forbidden by DRM") );
                 }
 #ifdef HAVE_SPEECH
                 if ( Okular::Settings::useTTS() )
                     speakText = menu.addAction( QIcon::fromTheme(QStringLiteral("text-speak")), i18n( "Speak Text" ) );
 #endif
                 if ( copyAllowed )
                 {
                     addWebShortcutsMenu( &menu, selectedText );
                 }
             }
             menu.addAction( new OKMenuTitle( &menu, i18n( "Image (%1 by %2 pixels)", selectionRect.width(), selectionRect.height() ) ) );
             imageToClipboard = menu.addAction( QIcon::fromTheme(QStringLiteral("image-x-generic")), i18n( "Copy to Clipboard" ) );
             imageToFile = menu.addAction( QIcon::fromTheme(QStringLiteral("document-save")), i18n( "Save to File..." ) );
             QAction *choice = menu.exec( e->globalPos() );
             // check if the user really selected an action
             if ( choice )
             {
             // IMAGE operation chosen
             if ( choice == imageToClipboard || choice == imageToFile )
             {
                 // renders page into a pixmap
                 QPixmap copyPix( selectionRect.width(), selectionRect.height() );
                 QPainter copyPainter( &copyPix );
                 copyPainter.translate( -selectionRect.left(), -selectionRect.top() );
                 drawDocumentOnPainter( selectionRect, &copyPainter );
                 copyPainter.end();
 
                 if ( choice == imageToClipboard )
                 {
                     // [2] copy pixmap to clipboard
                     QClipboard *cb = QApplication::clipboard();
                     cb->setPixmap( copyPix, QClipboard::Clipboard );
                     if ( cb->supportsSelection() )
                         cb->setPixmap( copyPix, QClipboard::Selection );
                     d->messageWindow->display( i18n( "Image [%1x%2] copied to clipboard.", copyPix.width(), copyPix.height() ) );
                 }
                 else if ( choice == imageToFile )
                 {
                     // [3] save pixmap to file
                     QString fileName = QFileDialog::getSaveFileName(this, i18n("Save file"), QString(), i18n("Images (*.png *.jpeg)"));
                     if ( fileName.isEmpty() )
                         d->messageWindow->display( i18n( "File not saved." ), QString(), PageViewMessage::Warning );
                     else
                     {
                         QMimeDatabase db;
                         QMimeType mime = db.mimeTypeForUrl( QUrl::fromLocalFile(fileName) );
                         QString type;
                         if ( !mime.isDefault() )
                             type = QStringLiteral("PNG");
                         else
                             type = mime.name().section( QLatin1Char('/'), -1 ).toUpper();
                         copyPix.save( fileName, qPrintable( type ) );
                         d->messageWindow->display( i18n( "Image [%1x%2] saved to %3 file.", copyPix.width(), copyPix.height(), type ) );
                     }
                 }
             }
             // TEXT operation chosen
             else
             {
                 if ( choice == textToClipboard )
                 {
                     // [1] copy text to clipboard
                     QClipboard *cb = QApplication::clipboard();
                     cb->setText( selectedText, QClipboard::Clipboard );
                     if ( cb->supportsSelection() )
                         cb->setText( selectedText, QClipboard::Selection );
                 }
 #ifdef HAVE_SPEECH
                 else if ( choice == speakText )
                 {
                     // [2] speech selection using TTS
                     d->tts()->say( selectedText );
                 }
 #endif
             }
             }
             // clear widget selection and invalidate rect
             selectionClear();
 
             // restore previous action if came from it using right button
             if ( d->aPrevAction )
             {
                 d->aPrevAction->trigger();
                 d->aPrevAction = 0;
             }
             }break;
 
         case Okular::Settings::EnumMouseMode::TableSelect:
         {
             // if mouse is released and selection is null this is a rightClick
             if ( rightButton && !d->mouseSelecting )
             {
                 PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
                 emit rightClick( pageItem ? pageItem->page() : 0, e->globalPos() );
                 break;
             }
 
             QRect selectionRect = d->mouseSelectionRect.normalized();
             if ( selectionRect.width() <= 8 && selectionRect.height() <= 8 && d->tableSelectionParts.isEmpty() )
             {
                 selectionClear();
                 if ( d->aPrevAction )
                 {
                     d->aPrevAction->trigger();
                     d->aPrevAction = 0;
                 }
                 break;
             }
 
             if (d->mouseSelecting) {
                 // break up the selection into page-relative pieces
                 d->tableSelectionParts.clear();
                 const Okular::Page * okularPage=0;
                 QVector< PageViewItem * >::const_iterator iIt = d->items.constBegin(), iEnd = d->items.constEnd();
                 for ( ; iIt != iEnd; ++iIt )
                 {
                     PageViewItem * item = *iIt;
                     if ( !item->isVisible() )
                         continue;
 
                     const QRect & itemRect = item->croppedGeometry();
                     if ( selectionRect.intersects( itemRect ) )
                     {
                         // request the textpage if there isn't one
                         okularPage= item->page();
                         qCDebug(OkularUiDebug) << "checking if page" << item->pageNumber() << "has text:" << okularPage->hasTextPage();
                         if ( !okularPage->hasTextPage() )
                             d->document->requestTextPage( okularPage->number() );
                         // grab text in the rect that intersects itemRect
                         QRect rectInItem = selectionRect.intersected( itemRect );
                         rectInItem.translate( -item->uncroppedGeometry().topLeft() );
                         QRect rectInSelection = selectionRect.intersected( itemRect );
                         rectInSelection.translate( -selectionRect.topLeft() );
                         d->tableSelectionParts.append(
                             TableSelectionPart(
                                 item,
                                 Okular::NormalizedRect( rectInItem, item->uncroppedWidth(), item->uncroppedHeight() ),
                                 Okular::NormalizedRect( rectInSelection, selectionRect.width(), selectionRect.height() )
                             )
                         );
                     }
                 }
 
                 QRect updatedRect = d->mouseSelectionRect.normalized().adjusted( 0, 0, 1, 1 );
                 updatedRect.translate( -contentAreaPosition() );
                 d->mouseSelecting = false;
                 d->mouseSelectionRect.setCoords( 0, 0, 0, 0 );
                 d->tableSelectionCols.clear();
                 d->tableSelectionRows.clear();
                 guessTableDividers();
                 viewport()->update( updatedRect );
             }
 
             if ( !d->document->isAllowed( Okular::AllowCopy ) ) {
                 d->messageWindow->display( i18n("Copy forbidden by DRM"), QString(), PageViewMessage::Info, -1 );
                 break;
             }
 
             QString selText;
             QString selHtml;
             QList<double> xs = d->tableSelectionCols;
             QList<double> ys = d->tableSelectionRows;
             xs.prepend(0.0);
             xs.append(1.0);
             ys.prepend(0.0);
             ys.append(1.0);
             selHtml = QString::fromLatin1("<html><head>"
                       "<meta content=\"text/html; charset=utf-8\" http-equiv=\"Content-Type\">"
                       "</head><body><table>");
             for (int r=0; r+1<ys.length(); r++) {
                 selHtml += QLatin1String("<tr>");
                 for (int c=0; c+1<xs.length(); c++) {
                     Okular::NormalizedRect cell(xs[c], ys[r], xs[c+1], ys[r+1]);
                     if (c) selText += QLatin1Char('\t');
                     QString txt;
                     foreach (const TableSelectionPart &tsp, d->tableSelectionParts) {
                         // first, crop the cell to this part
                         if (!tsp.rectInSelection.intersects(cell))
                             continue;
                         Okular::NormalizedRect cellPart = tsp.rectInSelection & cell; // intersection
 
                         // second, convert it from table coordinates to part coordinates
                         cellPart.left -= tsp.rectInSelection.left;
                         cellPart.left /= (tsp.rectInSelection.right - tsp.rectInSelection.left);
                         cellPart.right -= tsp.rectInSelection.left;
                         cellPart.right /= (tsp.rectInSelection.right - tsp.rectInSelection.left);
                         cellPart.top -= tsp.rectInSelection.top;
                         cellPart.top /= (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
                         cellPart.bottom -= tsp.rectInSelection.top;
                         cellPart.bottom /= (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
 
                         // third, convert from part coordinates to item coordinates
                         cellPart.left *= (tsp.rectInItem.right - tsp.rectInItem.left);
                         cellPart.left += tsp.rectInItem.left;
                         cellPart.right *= (tsp.rectInItem.right - tsp.rectInItem.left);
                         cellPart.right += tsp.rectInItem.left;
                         cellPart.top *= (tsp.rectInItem.bottom - tsp.rectInItem.top);
                         cellPart.top += tsp.rectInItem.top;
                         cellPart.bottom *= (tsp.rectInItem.bottom - tsp.rectInItem.top);
                         cellPart.bottom += tsp.rectInItem.top;
 
                         // now get the text
                         Okular::RegularAreaRect rects;
                         rects.append( cellPart );
                         txt += tsp.item->page()->text( &rects, Okular::TextPage::CentralPixelTextAreaInclusionBehaviour );
                     }
                     QString html = txt;
                     selText += txt.replace(QLatin1Char('\n'), QLatin1Char(' '));
                     html.replace(QLatin1Char('&'), QLatin1String("&amp;")).replace(QLatin1Char('<'), QLatin1String("&lt;")).replace(QLatin1Char('>'), QLatin1String("&gt;"));
                     // Remove newlines, do not turn them into <br>, because
                     // Excel interprets <br> within cell as new cell...
                     html.replace(QLatin1Char('\n'), QLatin1String(" "));
                     selHtml += QStringLiteral("<td>") + html + QStringLiteral("</td>");
                 }
                 selText += QLatin1Char('\n');
                 selHtml += QLatin1String("</tr>\n");
             }
             selHtml += QLatin1String("</table></body></html>\n");
 
 
             QClipboard *cb = QApplication::clipboard();
             QMimeData *md = new QMimeData();
             md->setText(selText);
             md->setHtml(selHtml);
             cb->setMimeData( md, QClipboard::Clipboard );
             if ( cb->supportsSelection() )
                 cb->setMimeData( md, QClipboard::Selection );
 
         }break;
             case Okular::Settings::EnumMouseMode::TextSelect:
                 if ( d->mouseTextSelecting )
                 {
                     d->mouseTextSelecting = false;
 //                    textSelectionClear();
                     if ( d->document->isAllowed( Okular::AllowCopy ) )
                     {
                         const QString text = d->selectedText();
                         if ( !text.isEmpty() )
                         {
                             QClipboard *cb = QApplication::clipboard();
                             if ( cb->supportsSelection() )
                                 cb->setText( text, QClipboard::Selection );
                         }
                     }
                 }
                 else if ( !d->mousePressPos.isNull() && rightButton )
                 {
                     PageViewItem* item = pickItemOnPoint(eventPos.x(),eventPos.y());
                     const Okular::Page *page;
                     //if there is text selected in the page
                     if (item && (page = item->page())->textSelection())
                     {
                         QMenu menu( this );
                         QAction *textToClipboard = menu.addAction( QIcon::fromTheme( QStringLiteral("edit-copy") ), i18n( "Copy Text" ) );
                         QAction *httpLink = 0;
 #ifdef HAVE_SPEECH
                         QAction *speakText = 0;
                         if ( Okular::Settings::useTTS() )
                             speakText = menu.addAction( QIcon::fromTheme( QStringLiteral("text-speak") ), i18n( "Speak Text" ) );
 #endif
                         if ( !d->document->isAllowed( Okular::AllowCopy ) )
                         {
                             textToClipboard->setEnabled( false );
                             textToClipboard->setText( i18n("Copy forbidden by DRM") );
                         }
                         else
                         {
                             addWebShortcutsMenu( &menu, d->selectedText() );
                         }
                         const QString url = UrlUtils::getUrl( d->selectedText() );
                         if ( !url.isEmpty() )
                         {
                             const QString squeezedText = KStringHandler::rsqueeze( url, 30 );
                             httpLink = menu.addAction( i18n( "Go to '%1'", squeezedText ) );
                         }
                         QAction *choice = menu.exec( e->globalPos() );
                         // check if the user really selected an action
                         if ( choice )
                         {
                             if ( choice == textToClipboard )
                                 copyTextSelection();
 #ifdef HAVE_SPEECH
                             else if ( choice == speakText )
                             {
                                 const QString text = d->selectedText();
                                 d->tts()->say( text );
                             }
 #endif
                             else if ( choice == httpLink )
                                 new KRun( QUrl( url ), this );
                         }
                     }
                 }
             break;
     }
 
     // reset mouse press / 'drag start' position
     d->mousePressPos = QPoint();
 }
 
 void PageView::guessTableDividers()
 {
     QList< QPair<double, int> > colTicks, rowTicks, colSelectionTicks, rowSelectionTicks;
 
     foreach ( const TableSelectionPart& tsp, d->tableSelectionParts )
     {
         // add ticks for the edges of this area...
         colSelectionTicks.append( qMakePair( tsp.rectInSelection.left,   +1 ) );
         colSelectionTicks.append( qMakePair( tsp.rectInSelection.right,  -1 ) );
         rowSelectionTicks.append( qMakePair( tsp.rectInSelection.top,    +1 ) );
         rowSelectionTicks.append( qMakePair( tsp.rectInSelection.bottom, -1 ) );
 
         // get the words in this part
         Okular::RegularAreaRect rects;
         rects.append( tsp.rectInItem );
         const Okular::TextEntity::List words = tsp.item->page()->words( &rects, Okular::TextPage::CentralPixelTextAreaInclusionBehaviour );
 
         foreach (Okular::TextEntity *te, words)
         {
             if (te->text().isEmpty()) {
                 delete te;
                 continue;
             }
 
             Okular::NormalizedRect wordArea = *te->area();
 
             // convert it from item coordinates to part coordinates
             wordArea.left -= tsp.rectInItem.left;
             wordArea.left /= (tsp.rectInItem.right - tsp.rectInItem.left);
             wordArea.right -= tsp.rectInItem.left;
             wordArea.right /= (tsp.rectInItem.right - tsp.rectInItem.left);
             wordArea.top -= tsp.rectInItem.top;
             wordArea.top /= (tsp.rectInItem.bottom - tsp.rectInItem.top);
             wordArea.bottom -= tsp.rectInItem.top;
             wordArea.bottom /= (tsp.rectInItem.bottom - tsp.rectInItem.top);
 
             // convert from part coordinates to table coordinates
             wordArea.left *= (tsp.rectInSelection.right - tsp.rectInSelection.left);
             wordArea.left += tsp.rectInSelection.left;
             wordArea.right *= (tsp.rectInSelection.right - tsp.rectInSelection.left);
             wordArea.right += tsp.rectInSelection.left;
             wordArea.top *= (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
             wordArea.top += tsp.rectInSelection.top;
             wordArea.bottom *= (tsp.rectInSelection.bottom - tsp.rectInSelection.top);
             wordArea.bottom += tsp.rectInSelection.top;
 
             // add to the ticks arrays...
             colTicks.append( qMakePair( wordArea.left,   +1) );
             colTicks.append( qMakePair( wordArea.right,  -1) );
             rowTicks.append( qMakePair( wordArea.top,    +1) );
             rowTicks.append( qMakePair( wordArea.bottom, -1) );
 
             delete te;
         }
     }
 
     int tally = 0;
 
     qSort( colSelectionTicks );
     qSort( rowSelectionTicks );
 
     for (int i = 0; i < colSelectionTicks.length(); ++i)
     {
         tally += colSelectionTicks[i].second;
         if ( tally == 0 && i + 1 < colSelectionTicks.length() && colSelectionTicks[i+1].first != colSelectionTicks[i].first)
         {
             colTicks.append( qMakePair( colSelectionTicks[i].first,   +1 ) );
             colTicks.append( qMakePair( colSelectionTicks[i+1].first, -1 ) );
         }
     }
     Q_ASSERT( tally == 0 );
 
     for (int i = 0; i < rowSelectionTicks.length(); ++i)
     {
         tally += rowSelectionTicks[i].second;
         if ( tally == 0 && i + 1 < rowSelectionTicks.length() && rowSelectionTicks[i+1].first != rowSelectionTicks[i].first) {
             rowTicks.append( qMakePair( rowSelectionTicks[i].first,   +1 ) );
             rowTicks.append( qMakePair( rowSelectionTicks[i+1].first, -1 ) );
         }
     }
     Q_ASSERT( tally == 0 );
 
     qSort( colTicks );
     qSort( rowTicks );
 
     for (int i = 0; i < colTicks.length(); ++i)
     {
         tally += colTicks[i].second;
         if ( tally == 0 && i + 1 < colTicks.length() && colTicks[i+1].first != colTicks[i].first)
         {
             d->tableSelectionCols.append( (colTicks[i].first+colTicks[i+1].first) / 2 );
             d->tableDividersGuessed = true;
         }
     }
     Q_ASSERT( tally == 0 );
 
     for (int i = 0; i < rowTicks.length(); ++i)
     {
         tally += rowTicks[i].second;
         if ( tally == 0 && i + 1 < rowTicks.length() && rowTicks[i+1].first != rowTicks[i].first)
         {
             d->tableSelectionRows.append( (rowTicks[i].first+rowTicks[i+1].first) / 2 );
             d->tableDividersGuessed = true;
         }
     }
     Q_ASSERT( tally == 0 );
 }
 
 void PageView::mouseDoubleClickEvent( QMouseEvent * e )
 {
     d->controlWheelAccumulatedDelta = 0;
 
     if ( e->button() == Qt::LeftButton )
     {
         const QPoint eventPos = contentAreaPoint( e->pos() );
         PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
         if ( pageItem )
         {
             // find out normalized mouse coords inside current item
             double nX = pageItem->absToPageX(eventPos.x());
             double nY = pageItem->absToPageY(eventPos.y());
 
             if ( d->mouseMode == Okular::Settings::EnumMouseMode::TextSelect ) {
                 textSelectionClear();
 
                 Okular::RegularAreaRect *wordRect = pageItem->page()->wordAt( Okular::NormalizedPoint( nX, nY ) );
                 if ( wordRect )
                 {
                     // TODO words with hyphens across pages
                     d->document->setPageTextSelection( pageItem->pageNumber(), wordRect, palette().color( QPalette::Active, QPalette::Highlight ) );
                     d->pagesWithTextSelection << pageItem->pageNumber();
                     if ( d->document->isAllowed( Okular::AllowCopy ) )
                     {
                         const QString text = d->selectedText();
                         if ( !text.isEmpty() )
                         {
                             QClipboard *cb = QApplication::clipboard();
                             if ( cb->supportsSelection() )
                                 cb->setText( text, QClipboard::Selection );
                         }
                     }
                     return;
                 }
             }
 
             const QRect & itemRect = pageItem->uncroppedGeometry();
             Okular::Annotation * ann = 0;
             const Okular::ObjectRect * orect = pageItem->page()->objectRect( Okular::ObjectRect::OAnnotation, nX, nY, itemRect.width(), itemRect.height() );
             if ( orect )
                 ann = ( (Okular::AnnotationObjectRect *)orect )->annotation();
             if ( ann && ann->subType() != Okular::Annotation::AWidget )
             {
                 openAnnotationWindow( ann, pageItem->pageNumber() );
             }
         }
     }
 }
 
 void PageView::wheelEvent( QWheelEvent *e )
 {
     // don't perform any mouse action when viewport is autoscrolling
     if ( d->viewportMoveActive )
         return;
 
     if ( !d->document->isOpened() )
     {
         QAbstractScrollArea::wheelEvent( e );
         return;
     }
 
     int delta = e->delta(),
         vScroll = verticalScrollBar()->value();
     e->accept();
     if ( (e->modifiers() & Qt::ControlModifier) == Qt::ControlModifier ) {
         d->controlWheelAccumulatedDelta += delta;
         if ( d->controlWheelAccumulatedDelta <= -QWheelEvent::DefaultDeltasPerStep )
         {
             slotZoomOut();
             d->controlWheelAccumulatedDelta = 0;
         }
         else if ( d->controlWheelAccumulatedDelta >= QWheelEvent::DefaultDeltasPerStep )
         {
             slotZoomIn();
             d->controlWheelAccumulatedDelta = 0;
         }
     }
     else
     {
         d->controlWheelAccumulatedDelta = 0;
 
         if ( delta <= -QWheelEvent::DefaultDeltasPerStep && !Okular::Settings::viewContinuous() && vScroll == verticalScrollBar()->maximum() )
         {
             // go to next page
             if ( (int)d->document->currentPage() < d->items.count() - 1 )
             {
                 // more optimized than document->setNextPage and then move view to top
                 Okular::DocumentViewport newViewport = d->document->viewport();
                 newViewport.pageNumber += viewColumns();
                 if ( newViewport.pageNumber >= (int)d->items.count() )
                     newViewport.pageNumber = d->items.count() - 1;
                 newViewport.rePos.enabled = true;
                 newViewport.rePos.normalizedY = 0.0;
                 d->document->setViewport( newViewport );
             }
         }
         else if ( delta >= QWheelEvent::DefaultDeltasPerStep && !Okular::Settings::viewContinuous() && vScroll == verticalScrollBar()->minimum() )
         {
             // go to prev page
             if ( d->document->currentPage() > 0 )
             {
                 // more optimized than document->setPrevPage and then move view to bottom
                 Okular::DocumentViewport newViewport = d->document->viewport();
                 newViewport.pageNumber -= viewColumns();
                 if ( newViewport.pageNumber < 0 )
                     newViewport.pageNumber = 0;
                 newViewport.rePos.enabled = true;
                 newViewport.rePos.normalizedY = 1.0;
                 d->document->setViewport( newViewport );
             }
         }
         else
             QAbstractScrollArea::wheelEvent( e );
     }
 
     updateCursor();
 }
 
 bool PageView::viewportEvent( QEvent * e )
 {
     if ( e->type() == QEvent::ToolTip && d->mouseMode == Okular::Settings::EnumMouseMode::Browse )
     {
         QHelpEvent * he = static_cast< QHelpEvent* >( e );
         if ( d->mouseAnnotation->isMouseOver() )
         {
             d->mouseAnnotation->routeTooltipEvent( he );
         }
         else
         {
             const QPoint eventPos = contentAreaPoint( he->pos() );
             PageViewItem * pageItem = pickItemOnPoint( eventPos.x(), eventPos.y() );
             const Okular::ObjectRect * rect = 0;
             const Okular::Action * link = 0;
             if ( pageItem )
             {
                 double nX = pageItem->absToPageX( eventPos.x() );
                 double nY = pageItem->absToPageY( eventPos.y() );
                 rect = pageItem->page()->objectRect( Okular::ObjectRect::Action, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                 if ( rect )
                     link = static_cast< const Okular::Action * >( rect->object() );
             }
 
             if ( link )
             {
                 QRect r = rect->boundingRect( pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                 r.translate( pageItem->uncroppedGeometry().topLeft() );
                 r.translate( -contentAreaPosition() );
                 QString tip = link->actionTip();
                 if ( !tip.isEmpty() )
                     QToolTip::showText( he->globalPos(), tip, viewport(), r );
             }
         }
         e->accept();
         return true;
     }
     else
         // do not stop the event
         return QAbstractScrollArea::viewportEvent( e );
 }
 
 void PageView::scrollContentsBy( int dx, int dy )
 {
     const QRect r = viewport()->rect();
     viewport()->scroll( dx, dy, r );
     // HACK manually repaint the damaged regions, as it seems some updates are missed
     // thus leaving artifacts around
     QRegion rgn( r );
     rgn -= rgn & r.translated( dx, dy );
     foreach ( const QRect &rect, rgn.rects() )
         viewport()->repaint( rect );
 }
 //END widget events
 
 QList< Okular::RegularAreaRect * > PageView::textSelections( const QPoint& start, const QPoint& end, int& firstpage )
 {
     firstpage = -1;
     QList< Okular::RegularAreaRect * > ret;
     QSet< int > affectedItemsSet;
     QRect selectionRect = QRect( start, end ).normalized();
     foreach( PageViewItem * item, d->items )
     {
         if ( item->isVisible() && selectionRect.intersects( item->croppedGeometry() ) )
             affectedItemsSet.insert( item->pageNumber() );
     }
 #ifdef PAGEVIEW_DEBUG
     qCDebug(OkularUiDebug) << ">>>> item selected by mouse:" << affectedItemsSet.count();
 #endif
 
     if ( !affectedItemsSet.isEmpty() )
     {
         // is the mouse drag line the ne-sw diagonal of the selection rect?
         bool direction_ne_sw = start == selectionRect.topRight() || start == selectionRect.bottomLeft();
 
         int tmpmin = d->document->pages();
         int tmpmax = 0;
         foreach( int p, affectedItemsSet )
         {
             if ( p < tmpmin ) tmpmin = p;
             if ( p > tmpmax ) tmpmax = p;
         }
 
         PageViewItem * a = pickItemOnPoint( (int)( direction_ne_sw ? selectionRect.right() : selectionRect.left() ), (int)selectionRect.top() );
         int min = a && ( a->pageNumber() != tmpmax ) ? a->pageNumber() : tmpmin;
         PageViewItem * b = pickItemOnPoint( (int)( direction_ne_sw ? selectionRect.left() : selectionRect.right() ), (int)selectionRect.bottom() );
         int max = b && ( b->pageNumber() != tmpmin ) ? b->pageNumber() : tmpmax;
 
         QList< int > affectedItemsIds;
         for ( int i = min; i <= max; ++i )
             affectedItemsIds.append( i );
 #ifdef PAGEVIEW_DEBUG
         qCDebug(OkularUiDebug) << ">>>> pages:" << affectedItemsIds;
 #endif
         firstpage = affectedItemsIds.first();
 
         if ( affectedItemsIds.count() == 1 )
         {
             PageViewItem * item = d->items[ affectedItemsIds.first() ];
             selectionRect.translate( -item->uncroppedGeometry().topLeft() );
             ret.append( textSelectionForItem( item,
                 direction_ne_sw ? selectionRect.topRight() : selectionRect.topLeft(),
                 direction_ne_sw ? selectionRect.bottomLeft() : selectionRect.bottomRight() ) );
         }
         else if ( affectedItemsIds.count() > 1 )
         {
             // first item
             PageViewItem * first = d->items[ affectedItemsIds.first() ];
             QRect geom = first->croppedGeometry().intersected( selectionRect ).translated( -first->uncroppedGeometry().topLeft() );
             ret.append( textSelectionForItem( first,
                 selectionRect.bottom() > geom.height() ? ( direction_ne_sw ? geom.topRight() : geom.topLeft() ) : ( direction_ne_sw ? geom.bottomRight() : geom.bottomLeft() ),
                 QPoint() ) );
             // last item
             PageViewItem * last = d->items[ affectedItemsIds.last() ];
             geom = last->croppedGeometry().intersected( selectionRect ).translated( -last->uncroppedGeometry().topLeft() );
             // the last item needs to appended at last...
             Okular::RegularAreaRect * lastArea = textSelectionForItem( last,
                 QPoint(),
                 selectionRect.bottom() > geom.height() ? ( direction_ne_sw ? geom.bottomLeft() : geom.bottomRight() ) : ( direction_ne_sw ? geom.topLeft() : geom.topRight() ) );
             affectedItemsIds.removeFirst();
             affectedItemsIds.removeLast();
             // item between the two above
             foreach( int page, affectedItemsIds )
             {
                 ret.append( textSelectionForItem( d->items[ page ] ) );
             }
             ret.append( lastArea );
         }
     }
     return ret;
 }
 
 
 void PageView::drawDocumentOnPainter( const QRect & contentsRect, QPainter * p )
 {
     QColor backColor = viewport()->palette().color( QPalette::Dark );
 
     // when checking if an Item is contained in contentsRect, instead of
     // growing PageViewItems rects (for keeping outline into account), we
     // grow the contentsRect
     QRect checkRect = contentsRect;
     checkRect.adjust( -3, -3, 1, 1 );
 
     // create a region from which we'll subtract painted rects
     QRegion remainingArea( contentsRect );
 
     // iterate over all items painting the ones intersecting contentsRect
     QVector< PageViewItem * >::const_iterator iIt = d->items.constBegin(), iEnd = d->items.constEnd();
     for ( ; iIt != iEnd; ++iIt )
     {
         // check if a piece of the page intersects the contents rect
         if ( !(*iIt)->isVisible() || !(*iIt)->croppedGeometry().intersects( checkRect ) )
             continue;
 
         // get item and item's outline geometries
         PageViewItem * item = *iIt;
         QRect itemGeometry = item->croppedGeometry(),
               outlineGeometry = itemGeometry;
         outlineGeometry.adjust( -1, -1, 3, 3 );
 
         // move the painter to the top-left corner of the real page
         p->save();
         p->translate( itemGeometry.left(), itemGeometry.top() );
 
         // draw the page outline (black border and 2px bottom-right shadow)
         if ( !itemGeometry.contains( contentsRect ) )
         {
             int itemWidth = itemGeometry.width(),
                 itemHeight = itemGeometry.height();
             // draw simple outline
             p->setPen( Qt::black );
             p->drawRect( -1, -1, itemWidth + 1, itemHeight + 1 );
             // draw bottom/right gradient
             static const int levels = 2;
             int r = backColor.red() / (levels + 2) + 6,
                 g = backColor.green() / (levels + 2) + 6,
                 b = backColor.blue() / (levels + 2) + 6;
             for ( int i = 0; i < levels; i++ )
             {
                 p->setPen( QColor( r * (i+2), g * (i+2), b * (i+2) ) );
                 p->drawLine( i, i + itemHeight + 1, i + itemWidth + 1, i + itemHeight + 1 );
                 p->drawLine( i + itemWidth + 1, i, i + itemWidth + 1, i + itemHeight );
                 p->setPen( backColor );
                 p->drawLine( -1, i + itemHeight + 1, i - 1, i + itemHeight + 1 );
                 p->drawLine( i + itemWidth + 1, -1, i + itemWidth + 1, i - 1 );
             }
         }
 
         // draw the page using the PagePainter with all flags active
         if ( contentsRect.intersects( itemGeometry ) )
         {
             Okular::NormalizedPoint *viewPortPoint = 0;
             Okular::NormalizedPoint point( d->lastSourceLocationViewportNormalizedX, d->lastSourceLocationViewportNormalizedY );
             if( Okular::Settings::showSourceLocationsGraphically()
                 && item->pageNumber() ==  d->lastSourceLocationViewportPageNumber )
             {
                 viewPortPoint = &point;
             }
             QRect pixmapRect = contentsRect.intersected( itemGeometry );
             pixmapRect.translate( -item->croppedGeometry().topLeft() );
             PagePainter::paintCroppedPageOnPainter( p, item->page(), this, pageflags,
                 item->uncroppedWidth(), item->uncroppedHeight(), pixmapRect,
                 item->crop(), viewPortPoint );
         }
 
         // remove painted area from 'remainingArea' and restore painter
         remainingArea -= outlineGeometry.intersected( contentsRect );
         p->restore();
     }
 
     // fill with background color the unpainted area
     const QVector<QRect> &backRects = remainingArea.rects();
     int backRectsNumber = backRects.count();
     for ( int jr = 0; jr < backRectsNumber; jr++ )
         p->fillRect( backRects[ jr ], backColor );
 }
 
 void PageView::updateItemSize( PageViewItem * item, int colWidth, int rowHeight )
 {
     const Okular::Page * okularPage = item->page();
     double width = okularPage->width(),
            height = okularPage->height(),
            zoom = d->zoomFactor;
     Okular::NormalizedRect crop( 0., 0., 1., 1. );
 
     // Handle cropping, due to either "Trim Margin" or "Trim to Selection" cases
     if (( Okular::Settings::trimMargins() && okularPage->isBoundingBoxKnown()
          && !okularPage->boundingBox().isNull() ) ||
         ( d->aTrimToSelection && d->aTrimToSelection->isChecked() &&  !d->trimBoundingBox.isNull()))
     {
 
         crop = Okular::Settings::trimMargins() ? okularPage->boundingBox() : d->trimBoundingBox;
 
         // Rotate the bounding box
         for ( int i = okularPage->rotation(); i > 0; --i )
         {
             Okular::NormalizedRect rot = crop;
             crop.left   = 1 - rot.bottom;
             crop.top    = rot.left;
             crop.right  = 1 - rot.top;
             crop.bottom = rot.right;
         }
 
         // Expand the crop slightly beyond the bounding box (for Trim Margins only)
         if (Okular::Settings::trimMargins()) {
             static const double cropExpandRatio = 0.04;
             const double cropExpand = cropExpandRatio * ( (crop.right-crop.left) + (crop.bottom-crop.top) ) / 2;
             crop = Okular::NormalizedRect(
                 crop.left - cropExpand,
                 crop.top - cropExpand,
                 crop.right + cropExpand,
                 crop.bottom + cropExpand ) & Okular::NormalizedRect( 0, 0, 1, 1 );
         }
 
         // We currently generate a larger image and then crop it, so if the
         // crop rect is very small the generated image is huge. Hence, we shouldn't
         // let the crop rect become too small.
         static double minCropRatio;
         if (Okular::Settings::trimMargins()) {
             // Make sure we crop by at most 50% in either dimension:
             minCropRatio = 0.5;
         } else {
             // Looser Constraint for "Trim Selection"
             minCropRatio = 0.20;
         }
         if ( ( crop.right - crop.left ) < minCropRatio )
         {
             const double newLeft = ( crop.left + crop.right ) / 2 - minCropRatio/2;
             crop.left = qMax( 0.0, qMin( 1.0 - minCropRatio, newLeft ) );
             crop.right = crop.left + minCropRatio;
         }
         if ( ( crop.bottom - crop.top ) < minCropRatio )
         {
             const double newTop = ( crop.top + crop.bottom ) / 2 - minCropRatio/2;
             crop.top = qMax( 0.0, qMin( 1.0 - minCropRatio, newTop ) );
             crop.bottom = crop.top + minCropRatio;
         }
 
         width *= ( crop.right - crop.left );
         height *= ( crop.bottom - crop.top );
 #ifdef PAGEVIEW_DEBUG
         qCDebug(OkularUiDebug) << "Cropped page" << okularPage->number() << "to" << crop
                  << "width" << width << "height" << height << "by bbox" << okularPage->boundingBox();
 #endif
     }
 
     if ( d->zoomMode == ZoomFixed )
     {
         width *= zoom;
         height *= zoom;
         item->setWHZC( (int)width, (int)height, d->zoomFactor, crop );
     }
     else if ( d->zoomMode == ZoomFitWidth )
     {
         height = ( height / width ) * colWidth;
         zoom = (double)colWidth / width;
         item->setWHZC( colWidth, (int)height, zoom, crop );
         if ((uint)item->pageNumber() == d->document->currentPage())
             d->zoomFactor = zoom;
     }
     else if ( d->zoomMode == ZoomFitPage )
     {
         const double scaleW = (double)colWidth / (double)width;
         const double scaleH = (double)rowHeight / (double)height;
         zoom = qMin( scaleW, scaleH );
         item->setWHZC( (int)(zoom * width), (int)(zoom * height), zoom, crop );
         if ((uint)item->pageNumber() == d->document->currentPage())
             d->zoomFactor = zoom;
     }
     else if ( d->zoomMode == ZoomFitAuto )
     {
         const double aspectRatioRelation = 1.25; // relation between aspect ratios for "auto fit"
         const double uiAspect = (double)rowHeight / (double)colWidth;
         const double pageAspect = (double)height / (double)width;
         const double rel = uiAspect / pageAspect;
 
         const bool isContinuous = Okular::Settings::viewContinuous();
         if ( !isContinuous && rel > aspectRatioRelation )
         {
             // UI space is relatively much higher than the page
             zoom = (double)rowHeight / (double)height;
         }
         else if ( rel < 1.0 / aspectRatioRelation )
         {
             // UI space is relatively much wider than the page in relation
             zoom = (double)colWidth / (double)width;
         }
         else
         {
             // aspect ratios of page and UI space are very similar
             const double scaleW = (double)colWidth / (double)width;
             const double scaleH = (double)rowHeight / (double)height;
             zoom = qMin( scaleW, scaleH );
         }
         item->setWHZC( (int)(zoom * width), (int)(zoom * height), zoom, crop );
         if ((uint)item->pageNumber() == d->document->currentPage())
             d->zoomFactor = zoom;
     }
 #ifndef NDEBUG
     else
         qCDebug(OkularUiDebug) << "calling updateItemSize with unrecognized d->zoomMode!";
 #endif
 }
 
 PageViewItem * PageView::pickItemOnPoint( int x, int y )
 {
     PageViewItem * item = 0;
     QLinkedList< PageViewItem * >::const_iterator iIt = d->visibleItems.constBegin(), iEnd = d->visibleItems.constEnd();
     for ( ; iIt != iEnd; ++iIt )
     {
         PageViewItem * i = *iIt;
         const QRect & r = i->croppedGeometry();
         if ( x < r.right() && x > r.left() && y < r.bottom() )
         {
             if ( y > r.top() )
                 item = i;
             break;
         }
     }
     return item;
 }
 
 void PageView::textSelectionClear()
 {
    // something to clear
     if ( !d->pagesWithTextSelection.isEmpty() )
     {
         QSet< int >::ConstIterator it = d->pagesWithTextSelection.constBegin(), itEnd = d->pagesWithTextSelection.constEnd();
         for ( ; it != itEnd; ++it )
             d->document->setPageTextSelection( *it, 0, QColor() );
         d->pagesWithTextSelection.clear();
     }
 }
 
 void PageView::selectionStart( const QPoint & pos, const QColor & color, bool /*aboveAll*/ )
 {
     selectionClear();
     d->mouseSelecting = true;
     d->mouseSelectionRect.setRect( pos.x(), pos.y(), 1, 1 );
     d->mouseSelectionColor = color;
     // ensures page doesn't scroll
     if ( d->autoScrollTimer )
     {
         d->scrollIncrement = 0;
         d->autoScrollTimer->stop();
     }
 }
 
 void PageView::scrollPosIntoView( const QPoint & pos )
 {
     if (pos.x() < horizontalScrollBar()->value()) d->dragScrollVector.setX(pos.x() - horizontalScrollBar()->value());
     else if (horizontalScrollBar()->value() + viewport()->width() < pos.x()) d->dragScrollVector.setX(pos.x() - horizontalScrollBar()->value() - viewport()->width());
     else d->dragScrollVector.setX(0);
 
     if (pos.y() < verticalScrollBar()->value()) d->dragScrollVector.setY(pos.y() - verticalScrollBar()->value());
     else if (verticalScrollBar()->value() + viewport()->height() < pos.y()) d->dragScrollVector.setY(pos.y() - verticalScrollBar()->value() - viewport()->height());
     else d->dragScrollVector.setY(0);
 
     if (d->dragScrollVector != QPoint(0, 0))
     {
         if (!d->dragScrollTimer.isActive()) d->dragScrollTimer.start(100);
     }
     else d->dragScrollTimer.stop();
 }
 
 void PageView::updateSelection( const QPoint & pos )
 {
     if ( d->mouseSelecting )
     {
         scrollPosIntoView( pos );
         // update the selection rect
         QRect updateRect = d->mouseSelectionRect;
         d->mouseSelectionRect.setBottomLeft( pos );
         updateRect |= d->mouseSelectionRect;
         updateRect.translate( -contentAreaPosition() );
         viewport()->update( updateRect.adjusted( -1, -2, 2, 1 ) );
     }
     else if ( d->mouseTextSelecting)
     {
         scrollPosIntoView( pos );
         int first = -1;
         const QList< Okular::RegularAreaRect * > selections = textSelections( pos, d->mouseSelectPos, first );
         QSet< int > pagesWithSelectionSet;
         for ( int i = 0; i < selections.count(); ++i )
             pagesWithSelectionSet.insert( i + first );
 
         const QSet< int > noMoreSelectedPages = d->pagesWithTextSelection - pagesWithSelectionSet;
         // clear the selection from pages not selected anymore
         foreach( int p, noMoreSelectedPages )
         {
             d->document->setPageTextSelection( p, 0, QColor() );
         }
         // set the new selection for the selected pages
         foreach( int p, pagesWithSelectionSet )
         {
             d->document->setPageTextSelection( p, selections[ p - first ], palette().color( QPalette::Active, QPalette::Highlight ) );
         }
         d->pagesWithTextSelection = pagesWithSelectionSet;
     }
 }
 
 static Okular::NormalizedPoint rotateInNormRect( const QPoint &rotated, const QRect &rect, Okular::Rotation rotation )
 {
     Okular::NormalizedPoint ret;
 
     switch ( rotation )
     {
         case Okular::Rotation0:
             ret = Okular::NormalizedPoint( rotated.x(), rotated.y(), rect.width(), rect.height() );
             break;
         case Okular::Rotation90:
             ret = Okular::NormalizedPoint( rotated.y(), rect.width() - rotated.x(), rect.height(), rect.width() );
             break;
         case Okular::Rotation180:
             ret = Okular::NormalizedPoint( rect.width() - rotated.x(), rect.height() - rotated.y(), rect.width(), rect.height() );
             break;
         case Okular::Rotation270:
             ret = Okular::NormalizedPoint( rect.height() - rotated.y(), rotated.x(), rect.height(), rect.width() );
             break;
     }
 
     return ret;
 }
 
 Okular::RegularAreaRect * PageView::textSelectionForItem( PageViewItem * item, const QPoint & startPoint, const QPoint & endPoint )
 {
     const QRect & geometry = item->uncroppedGeometry();
     Okular::NormalizedPoint startCursor( 0.0, 0.0 );
     if ( !startPoint.isNull() )
     {
         startCursor = rotateInNormRect( startPoint, geometry, item->page()->rotation() );
     }
     Okular::NormalizedPoint endCursor( 1.0, 1.0 );
     if ( !endPoint.isNull() )
     {
         endCursor = rotateInNormRect( endPoint, geometry, item->page()->rotation() );
     }
     Okular::TextSelection mouseTextSelectionInfo( startCursor, endCursor );
 
     const Okular::Page * okularPage = item->page();
 
     if ( !okularPage->hasTextPage() )
         d->document->requestTextPage( okularPage->number() );
 
     Okular::RegularAreaRect * selectionArea = okularPage->textArea( &mouseTextSelectionInfo );
 #ifdef PAGEVIEW_DEBUG
     qCDebug(OkularUiDebug).nospace() << "text areas (" << okularPage->number() << "): " << ( selectionArea ? QString::number( selectionArea->count() ) : "(none)" );
 #endif
     return selectionArea;
 }
 
 void PageView::selectionClear(const ClearMode mode)
 {
     QRect updatedRect = d->mouseSelectionRect.normalized().adjusted( -2, -2, 2, 2 );
     d->mouseSelecting = false;
     d->mouseSelectionRect.setCoords( 0, 0, 0, 0 );
     d->tableSelectionCols.clear();
     d->tableSelectionRows.clear();
     d->tableDividersGuessed = false;
     foreach (const TableSelectionPart &tsp, d->tableSelectionParts) {
         QRect selectionPartRect = tsp.rectInItem.geometry(tsp.item->uncroppedWidth(), tsp.item->uncroppedHeight());
         selectionPartRect.translate( tsp.item->uncroppedGeometry().topLeft () );
         // should check whether this is on-screen here?
         updatedRect = updatedRect.united(selectionPartRect);
     }
     if ( mode != ClearOnlyDividers ) {
         d->tableSelectionParts.clear();
     }
     d->tableSelectionParts.clear();
     updatedRect.translate( -contentAreaPosition() );
     viewport()->update( updatedRect );
 }
 
 // const to be used for both zoomFactorFitMode function and slotRelayoutPages.
 static const int kcolWidthMargin = 6;
 static const int krowHeightMargin = 12;
 
 double PageView::zoomFactorFitMode( ZoomMode mode )
 {
     const int pageCount = d->items.count();
     if ( pageCount == 0 )
         return 0;
     const bool facingCentered = Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::FacingFirstCentered || (Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Facing && pageCount == 1);
     const bool overrideCentering = facingCentered && pageCount < 3;
     const int nCols = overrideCentering ? 1 : viewColumns();
     const double colWidth = viewport()->width() / nCols - kcolWidthMargin;
     const double rowHeight = viewport()->height() - krowHeightMargin;
     const PageViewItem * currentItem = d->items[ qMax( 0, (int)d->document->currentPage()) ];
     // prevent segmentation fault when openning a new document;
     if ( !currentItem )
         return 0;
     const Okular::Page * okularPage = currentItem->page();
     const double width = okularPage->width(), height = okularPage->height();
     if ( mode == ZoomFitWidth )
         return (double) colWidth / width;
     if ( mode == ZoomFitPage )
     {
         const double scaleW = (double) colWidth / (double)width;
         const double scaleH = (double) rowHeight / (double)height;
         return qMin(scaleW, scaleH);
     }
     return 0;
 }
 
 void PageView::updateZoom( ZoomMode newZoomMode )
 {
     if ( newZoomMode == ZoomFixed )
     {
         if ( d->aZoom->currentItem() == 0 )
             newZoomMode = ZoomFitWidth;
         else if ( d->aZoom->currentItem() == 1 )
             newZoomMode = ZoomFitPage;
         else if ( d->aZoom->currentItem() == 2 )
             newZoomMode = ZoomFitAuto;
     }
 
     float newFactor = d->zoomFactor;
     QAction * checkedZoomAction = 0;
     switch ( newZoomMode )
     {
         case ZoomFixed:{ //ZoomFixed case
             QString z = d->aZoom->currentText();
             // kdelibs4 sometimes adds accelerators to actions' text directly :(
             z.remove (QLatin1Char('&'));
             z.remove (QLatin1Char('%'));
             newFactor = QLocale().toDouble( z ) / 100.0;
             }break;
         case ZoomIn:
         case ZoomOut:{
             const float zoomFactorFitWidth = zoomFactorFitMode(ZoomFitWidth);
             const float zoomFactorFitPage = zoomFactorFitMode(ZoomFitPage);
             QVector<float> zoomValue(15);
             qCopy(kZoomValues, kZoomValues + 13, zoomValue.begin());
             zoomValue[13] = zoomFactorFitWidth;
             zoomValue[14] = zoomFactorFitPage;
             qSort(zoomValue.begin(), zoomValue.end());
             QVector<float>::iterator i;
             if ( newZoomMode == ZoomOut )
             {
                 if (newFactor <= zoomValue.first())
                     return;
                 i = qLowerBound(zoomValue.begin(), zoomValue.end(), newFactor) - 1;
             }
             else
             {
                 if (newFactor >= zoomValue.last())
                     return;
                 i = qUpperBound(zoomValue.begin(), zoomValue.end(), newFactor);
             }
             const float tmpFactor = *i;
             if ( tmpFactor == zoomFactorFitWidth )
             {
                 newZoomMode = ZoomFitWidth;
                 checkedZoomAction = d->aZoomFitWidth;
             }
             else if ( tmpFactor == zoomFactorFitPage )
             {
                 newZoomMode = ZoomFitPage;
                 checkedZoomAction = d->aZoomFitPage;
             }
             else
             {
                 newFactor = tmpFactor;
                 newZoomMode = ZoomFixed;
             }
             }
             break;
         case ZoomFitWidth:
             checkedZoomAction = d->aZoomFitWidth;
             break;
         case ZoomFitPage:
             checkedZoomAction = d->aZoomFitPage;
             break;
         case ZoomFitAuto:
             checkedZoomAction = d->aZoomAutoFit;
             break;
         case ZoomRefreshCurrent:
             newZoomMode = ZoomFixed;
             d->zoomFactor = -1;
             break;
     }
     const float upperZoomLimit = d->document->supportsTiles() ? 16.0 : 4.0;
     if ( newFactor > upperZoomLimit )
         newFactor = upperZoomLimit;
     if ( newFactor < 0.1 )
         newFactor = 0.1;
 
     if ( newZoomMode != d->zoomMode || (newZoomMode == ZoomFixed && newFactor != d->zoomFactor ) )
     {
         // rebuild layout and update the whole viewport
         d->zoomMode = newZoomMode;
         d->zoomFactor = newFactor;
         // be sure to block updates to document's viewport
         bool prevState = d->blockViewport;
         d->blockViewport = true;
         slotRelayoutPages();
         d->blockViewport = prevState;
         // request pixmaps
         slotRequestVisiblePixmaps();
         // update zoom text
         updateZoomText();
         // update actions checked state
         if ( d->aZoomFitWidth )
         {
             d->aZoomFitWidth->setChecked( checkedZoomAction == d->aZoomFitWidth );
             d->aZoomFitPage->setChecked( checkedZoomAction == d->aZoomFitPage );
             d->aZoomAutoFit->setChecked( checkedZoomAction == d->aZoomAutoFit );
         }
     }
     else if ( newZoomMode == ZoomFixed && newFactor == d->zoomFactor )
         updateZoomText();
 
     d->aZoomIn->setEnabled( d->zoomFactor < upperZoomLimit-0.001 );
     d->aZoomOut->setEnabled( d->zoomFactor > 0.101 );
 }
 
 void PageView::updateZoomText()
 {
     // use current page zoom as zoomFactor if in ZoomFit/* mode
     if ( d->zoomMode != ZoomFixed && d->items.count() > 0 )
         d->zoomFactor = d->items[ qMax( 0, (int)d->document->currentPage() ) ]->zoomFactor();
     float newFactor = d->zoomFactor;
     d->aZoom->removeAllActions();
 
     // add items that describe fit actions
     QStringList translated;
     translated << i18n("Fit Width") << i18n("Fit Page") << i18n("Auto Fit");
 
     // add percent items
     int idx = 0, selIdx = 3;
     bool inserted = false; //use: "d->zoomMode != ZoomFixed" to hide Fit/* zoom ratio
     int zoomValueCount = 11;
     if ( d->document->supportsTiles() )
         zoomValueCount = 13;
     while ( idx < zoomValueCount || !inserted )
     {
         float value = idx < zoomValueCount ? kZoomValues[ idx ] : newFactor;
         if ( !inserted && newFactor < (value - 0.0001) )
             value = newFactor;
         else
             idx ++;
         if ( value > (newFactor - 0.0001) && value < (newFactor + 0.0001) )
             inserted = true;
         if ( !inserted )
             selIdx++;
         // we do not need to display 2-digit precision
         QString localValue( QLocale().toString( value * 100.0, 'f', 1 ) );
         localValue.remove( QLocale().decimalPoint() + QLatin1Char('0') );
         // remove a trailing zero in numbers like 66.70
         if ( localValue.right( 1 ) == QLatin1String( "0" ) && localValue.indexOf( QLocale().decimalPoint() ) > -1 )
             localValue.chop( 1 );
         translated << QStringLiteral( "%1%" ).arg( localValue );
     }
     d->aZoom->setItems( translated );
 
     // select current item in list
     if ( d->zoomMode == ZoomFitWidth )
         selIdx = 0;
     else if ( d->zoomMode == ZoomFitPage )
         selIdx = 1;
     else if ( d->zoomMode == ZoomFitAuto )
         selIdx = 2;
     // we have to temporarily enable the actions as otherwise we can't set a new current item
     d->aZoom->setEnabled( true );
     d->aZoom->selectableActionGroup()->setEnabled( true );
     d->aZoom->setCurrentItem( selIdx );
     d->aZoom->setEnabled( d->items.size() > 0 );
     d->aZoom->selectableActionGroup()->setEnabled( d->items.size() > 0 );
 }
 
 void PageView::updateCursor()
 {
     const QPoint p = contentAreaPosition() + viewport()->mapFromGlobal( QCursor::pos() );
     updateCursor( p );
 }
 
 void PageView::updateCursor( const QPoint &p )
 {
     // detect the underlaying page (if present)
     PageViewItem * pageItem = pickItemOnPoint( p.x(), p.y() );
 
     if ( d->annotator && d->annotator->active() )
     {
         if ( pageItem || d->annotator->annotating() )
             setCursor( d->annotator->cursor() );
         else
             setCursor( Qt::ForbiddenCursor );
     }
     else if ( pageItem )
     {
         double nX = pageItem->absToPageX(p.x());
         double nY = pageItem->absToPageY(p.y());
 
         // if over a ObjectRect (of type Link) change cursor to hand
         if ( d->mouseMode == Okular::Settings::EnumMouseMode::TextSelect )
             setCursor( Qt::IBeamCursor );
         else if ( d->mouseMode == Okular::Settings::EnumMouseMode::Magnifier )
             setCursor( Qt::CrossCursor );
         else if ( d->mouseMode == Okular::Settings::EnumMouseMode::RectSelect )
             setCursor( Qt::CrossCursor );
         else if ( d->mouseMode == Okular::Settings::EnumMouseMode::TrimSelect )
             setCursor( Qt::CrossCursor );
         else if ( d->mouseMode == Okular::Settings::EnumMouseMode::Browse )
         {
             d->mouseOnRect = false;
             if ( d->mouseAnnotation->isMouseOver() )
             {
                 d->mouseOnRect = true;
                 setCursor( d->mouseAnnotation->cursor() );
             }
             else
             {
                 const Okular::ObjectRect * linkobj = pageItem->page()->objectRect( Okular::ObjectRect::Action, nX, nY, pageItem->uncroppedWidth(), pageItem->uncroppedHeight() );
                 if ( linkobj )
                 {
                     d->mouseOnRect = true;
                     setCursor( Qt::PointingHandCursor );
                 }
                 else
                 {
                     setCursor( Qt::OpenHandCursor );
                 }
             }
         }
         else
         {
             setCursor( Qt::ArrowCursor );
         }
     }
     else
     {
         // if there's no page over the cursor and we were showing the pointingHandCursor
         // go back to the normal one
         d->mouseOnRect = false;
         setCursor( Qt::ArrowCursor );
     }
 }
 
 void PageView::reloadForms()
 {
     QLinkedList< PageViewItem * >::const_iterator iIt = d->visibleItems.constBegin(), iEnd = d->visibleItems.constEnd();
     if( d->m_formsVisible )
     {
         for ( ; iIt != iEnd; ++iIt )
         {
             (*iIt)->reloadFormWidgetsState();
         }
     }
 
 }
 
 void PageView::moveMagnifier( const QPoint& p ) // non scaled point
 {
     const int w = d->magnifierView->width() * 0.5;
     const int h = d->magnifierView->height() * 0.5;
 
     int x = p.x() - w;
     int y = p.y() - h;
 
     const int max_x = viewport()->width();
     const int max_y = viewport()->height();
 
     QPoint scroll(0,0);
 
     if (x < 0)
     {
         if (horizontalScrollBar()->value() > 0) scroll.setX(x - w);
         x = 0;
     }
 
     if (y < 0)
     {
         if (verticalScrollBar()->value() > 0) scroll.setY(y - h);
         y = 0;
     }
 
     if (p.x() + w > max_x)
     {
         if (horizontalScrollBar()->value() < horizontalScrollBar()->maximum()) scroll.setX(p.x() + 2 * w - max_x);
         x = max_x - d->magnifierView->width() - 1;
     }
 
     if (p.y() + h > max_y)
     {
         if (verticalScrollBar()->value() < verticalScrollBar()->maximum()) scroll.setY(p.y() + 2 * h - max_y);
         y = max_y - d->magnifierView->height() - 1;
     }
 
     if (!scroll.isNull())
         scrollPosIntoView(contentAreaPoint(p + scroll));
 
     d->magnifierView->move(x, y);
 }
 
 void PageView::updateMagnifier( const QPoint& p ) // scaled point
 {
     /* translate mouse coordinates to page coordinates and inform the magnifier of the situation */
     PageViewItem *item = pickItemOnPoint(p.x(), p.y());
     if (item)
     {
         Okular::NormalizedPoint np(item->absToPageX(p.x()), item->absToPageY(p.y()));
         d->magnifierView->updateView( np, item->page() );
     }
 }
 
 int PageView::viewColumns() const
 {
     int vm = Okular::Settings::viewMode();
     if (vm == Okular::Settings::EnumViewMode::Single) return 1;
     else if (vm == Okular::Settings::EnumViewMode::Facing ||
              vm == Okular::Settings::EnumViewMode::FacingFirstCentered) return 2;
     else return Okular::Settings::viewColumns();
 }
 
 void PageView::center(int cx, int cy)
 {
     scrollTo( cx - viewport()->width() / 2, cy - viewport()->height() / 2 );
 }
 
 void PageView::scrollTo( int x, int y )
 {
     bool prevState = d->blockPixmapsRequest;
 
     int newValue = -1;
     if ( x != horizontalScrollBar()->value() || y != verticalScrollBar()->value() )
         newValue = 1; // Pretend this call is the result of a scrollbar event
 
     d->blockPixmapsRequest = true;
     horizontalScrollBar()->setValue( x );
     verticalScrollBar()->setValue( y );
 
     d->blockPixmapsRequest = prevState;
 
     slotRequestVisiblePixmaps( newValue );
 }
 
 void PageView::toggleFormWidgets( bool on )
 {
     bool somehadfocus = false;
     QVector< PageViewItem * >::const_iterator dIt = d->items.constBegin(), dEnd = d->items.constEnd();
     for ( ; dIt != dEnd; ++dIt )
     {
         bool hadfocus = (*dIt)->setFormWidgetsVisible( on );
         somehadfocus = somehadfocus || hadfocus;
     }
     if ( somehadfocus )
         setFocus();
     d->m_formsVisible = on;
     if ( d->aToggleForms ) // it may not exist if we are on dummy mode
     {
         if ( d->m_formsVisible )
         {
             d->aToggleForms->setText( i18n( "Hide Forms" ) );
         }
         else
         {
             d->aToggleForms->setText( i18n( "Show Forms" ) );
         }
     }
 }
 
 void PageView::resizeContentArea( const QSize & newSize )
 {
     const QSize vs = viewport()->size();
     int hRange = newSize.width() - vs.width();
     int vRange = newSize.height() - vs.height();
     if ( horizontalScrollBar()->isVisible() && hRange == verticalScrollBar()->width() && verticalScrollBar()->isVisible() && vRange == horizontalScrollBar()->height() && Okular::Settings::showScrollBars() )
     {
         hRange = 0;
         vRange = 0;
     }
     horizontalScrollBar()->setRange( 0, hRange );
     verticalScrollBar()->setRange( 0, vRange );
     updatePageStep();
 }
 
 void PageView::updatePageStep() {
     const QSize vs = viewport()->size();
     horizontalScrollBar()->setPageStep( vs.width() );
     verticalScrollBar()->setPageStep( vs.height() * (100 - Okular::Settings::scrollOverlap()) / 100 );
 }
 
 void PageView::addWebShortcutsMenu( QMenu * menu, const QString & text )
 {
     if ( text.isEmpty() )
     {
         return;
     }
 
     QString searchText = text;
     searchText = searchText.replace( QLatin1Char('\n'), QLatin1Char(' ') ).replace(QLatin1Char( '\r'), QLatin1Char(' ') ).simplified();
 
     if ( searchText.isEmpty() )
     {
         return;
     }
 
     KUriFilterData filterData( searchText );
 
     filterData.setSearchFilteringOptions( KUriFilterData::RetrievePreferredSearchProvidersOnly );
 
     if ( KUriFilter::self()->filterSearchUri( filterData, KUriFilter::NormalTextFilter ) )
     {
         const QStringList searchProviders = filterData.preferredSearchProviders();
 
         if ( !searchProviders.isEmpty() )
         {
             QMenu *webShortcutsMenu = new QMenu( menu );
             webShortcutsMenu->setIcon( QIcon::fromTheme( QStringLiteral("preferences-web-browser-shortcuts") ) );
 
             const QString squeezedText = KStringHandler::rsqueeze( searchText, 21 );
             webShortcutsMenu->setTitle( i18n( "Search for '%1' with", squeezedText ) );
 
             QAction *action = 0;
 
             foreach( const QString &searchProvider, searchProviders )
             {
                 action = new QAction( searchProvider, webShortcutsMenu );
                 action->setIcon( QIcon::fromTheme( filterData.iconNameForPreferredSearchProvider( searchProvider ) ) );
                 action->setData( filterData.queryForPreferredSearchProvider( searchProvider ) );
                 connect( action, &QAction::triggered, this, &PageView::slotHandleWebShortcutAction );
                 webShortcutsMenu->addAction( action );
             }
 
             webShortcutsMenu->addSeparator();
 
             action = new QAction( i18n( "Configure Web Shortcuts..." ), webShortcutsMenu );
             action->setIcon( QIcon::fromTheme( QStringLiteral("configure") ) );
             connect( action, &QAction::triggered, this, &PageView::slotConfigureWebShortcuts );
             webShortcutsMenu->addAction( action );
 
             menu->addMenu(webShortcutsMenu);
         }
     }
 }
 
 //BEGIN private SLOTS
 void PageView::slotRelayoutPages()
 // called by: notifySetup, viewportResizeEvent, slotViewMode, slotContinuousToggled, updateZoom
 {
     // set an empty container if we have no pages
     const int pageCount = d->items.count();
     if ( pageCount < 1 )
     {
         return;
     }
 
     // if viewport was auto-moving, stop it
     if ( d->viewportMoveActive )
     {
         center( d->viewportMoveDest.x(), d->viewportMoveDest.y() );
         d->viewportMoveActive = false;
         d->viewportMoveTimer->stop();
         verticalScrollBar()->setEnabled( true );
         horizontalScrollBar()->setEnabled( true );
     }
 
     // common iterator used in this method and viewport parameters
     QVector< PageViewItem * >::const_iterator iIt, iEnd = d->items.constEnd();
     int viewportWidth = viewport()->width(),
         viewportHeight = viewport()->height(),
         fullWidth = 0,
         fullHeight = 0;
     QRect viewportRect( horizontalScrollBar()->value(), verticalScrollBar()->value(), viewportWidth, viewportHeight );
 
     // handle the 'center first page in row' stuff
     const bool facing = Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Facing && pageCount > 1;
     const bool facingCentered = Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::FacingFirstCentered ||
                                (Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Facing && pageCount == 1);
     const bool overrideCentering = facingCentered && pageCount < 3;
     const bool centerFirstPage = facingCentered && !overrideCentering;
     const bool facingPages = facing || centerFirstPage;
     const bool centerLastPage = centerFirstPage && pageCount % 2 == 0;
     const bool continuousView = Okular::Settings::viewContinuous();
     const int nCols = overrideCentering ? 1 : viewColumns();
     const bool singlePageViewMode = Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Single;
 
     if ( d->aFitWindowToPage )
         d->aFitWindowToPage->setEnabled( !continuousView && singlePageViewMode );
 
     // set all items geometry and resize contents. handle 'continuous' and 'single' modes separately
 
     PageViewItem * currentItem = d->items[ qMax( 0, (int)d->document->currentPage() ) ];
 
         // Here we find out column's width and row's height to compute a table
         // so we can place widgets 'centered in virtual cells'.
         const int nRows = (int)ceil( (float)(centerFirstPage ? (pageCount + nCols - 1) : pageCount) / (float)nCols );
 
         int * colWidth = new int[ nCols ],
             * rowHeight = new int[ nRows ],
             cIdx = 0,
             rIdx = 0;
         for ( int i = 0; i < nCols; i++ )
             colWidth[ i ] = viewportWidth / nCols;
         for ( int i = 0; i < nRows; i++ )
             rowHeight[ i ] = 0;
         // handle the 'centering on first row' stuff
         if ( centerFirstPage )
             cIdx += nCols - 1;
 
         // 1) find the maximum columns width and rows height for a grid in
         // which each page must well-fit inside a cell
         for ( iIt = d->items.constBegin(); iIt != iEnd; ++iIt )
         {
             PageViewItem * item = *iIt;
             // update internal page size (leaving a little margin in case of Fit* modes)
             updateItemSize( item, colWidth[ cIdx ] - kcolWidthMargin, viewportHeight - krowHeightMargin );
             // find row's maximum height and column's max width
             if ( item->croppedWidth() + kcolWidthMargin > colWidth[ cIdx ] )
                 colWidth[ cIdx ] = item->croppedWidth() + kcolWidthMargin;
             if ( item->croppedHeight() + krowHeightMargin > rowHeight[ rIdx ] )
                 rowHeight[ rIdx ] = item->croppedHeight() + krowHeightMargin;
             // handle the 'centering on first row' stuff
             // update col/row indices
             if ( ++cIdx == nCols )
             {
                 cIdx = 0;
                 rIdx++;
             }
         }
 
         const int pageRowIdx = ( ( centerFirstPage ? nCols - 1 : 0 ) + currentItem->pageNumber() ) / nCols;
 
         // 2) compute full size
         for ( int i = 0; i < nCols; i++ )
             fullWidth += colWidth[ i ];
         if ( continuousView )
         {
             for ( int i = 0; i < nRows; i++ )
                 fullHeight += rowHeight[ i ];
         }
         else
             fullHeight = rowHeight[ pageRowIdx ];
 
         // 3) arrange widgets inside cells (and refine fullHeight if needed)
         int insertX = 0,
             insertY = fullHeight < viewportHeight ? ( viewportHeight - fullHeight ) / 2 : 0;
         const int origInsertY = insertY;
         cIdx = 0;
         rIdx = 0;
         if ( centerFirstPage )
         {
             cIdx += nCols - 1;
             for ( int i = 0; i < cIdx; ++i )
                 insertX += colWidth[ i ];
         }
         for ( iIt = d->items.constBegin(); iIt != iEnd; ++iIt )
         {
             PageViewItem * item = *iIt;
             int cWidth = colWidth[ cIdx ],
                 rHeight = rowHeight[ rIdx ];
             if ( continuousView || rIdx == pageRowIdx )
             {
                 const bool reallyDoCenterFirst = item->pageNumber() == 0 && centerFirstPage;
                 const bool reallyDoCenterLast = item->pageNumber() == pageCount - 1 && centerLastPage;
                 int actualX = 0;
                 if ( reallyDoCenterFirst || reallyDoCenterLast )
                 {
                     // page is centered across entire viewport
                     actualX = (fullWidth - item->croppedWidth()) / 2;
                 }
                 else if ( facingPages )
                 {
                     if (Okular::Settings::rtlReadingDirection()){
                         // RTL reading mode
                         actualX = ( (centerFirstPage && item->pageNumber() % 2 == 0) ||
                                     (!centerFirstPage && item->pageNumber() % 2 == 1) ) ?
                                     (fullWidth / 2) - item->croppedWidth() - 1 : (fullWidth / 2) + 1;
                     } else {
                         // page edges 'touch' the center of the viewport
                         actualX = ( (centerFirstPage && item->pageNumber() % 2 == 1) ||
                                     (!centerFirstPage && item->pageNumber() % 2 == 0) ) ?
                                     (fullWidth / 2) - item->croppedWidth() - 1 : (fullWidth / 2) + 1;
                     }
                 }
                 else
                 {
                     // page is centered within its virtual column
                     //actualX = insertX + (cWidth - item->croppedWidth()) / 2;
                     if (Okular::Settings::rtlReadingDirection()){
                         actualX = fullWidth - insertX - cWidth +( (cWidth - item->croppedWidth()) / 2);
                     } else {
                         actualX = insertX + (cWidth - item->croppedWidth()) / 2;
                     }
                 }
                 item->moveTo( actualX,
                               (continuousView ? insertY : origInsertY) + (rHeight - item->croppedHeight()) / 2 );
                 item->setVisible( true );
             }
             else
             {
                 item->moveTo( 0, 0 );
                 item->setVisible( false );
             }
             item->setFormWidgetsVisible( d->m_formsVisible );
             // advance col/row index
             insertX += cWidth;
             if ( ++cIdx == nCols )
             {
                 cIdx = 0;
                 rIdx++;
                 insertX = 0;
                 insertY += rHeight;
             }
 #ifdef PAGEVIEW_DEBUG
             kWarning() << "updating size for pageno" << item->pageNumber() << "cropped" << item->croppedGeometry() << "uncropped" << item->uncroppedGeometry();
 #endif
         }
 
         delete [] colWidth;
         delete [] rowHeight;
 
     // 3) reset dirty state
     d->dirtyLayout = false;
 
     // 4) update scrollview's contents size and recenter view
     bool wasUpdatesEnabled = viewport()->updatesEnabled();
     if ( fullWidth != contentAreaWidth() || fullHeight != contentAreaHeight() )
     {
         const Okular::DocumentViewport vp = d->document->viewport();
         // disable updates and resize the viewportContents
         if ( wasUpdatesEnabled )
             viewport()->setUpdatesEnabled( false );
         resizeContentArea( QSize( fullWidth, fullHeight ) );
         // restore previous viewport if defined and updates enabled
         if ( wasUpdatesEnabled )
         {
             if ( vp.pageNumber >= 0 )
             {
                 int prevX = horizontalScrollBar()->value(),
                     prevY = verticalScrollBar()->value();
                 const QRect & geometry = d->items[ vp.pageNumber ]->croppedGeometry();
                 double nX = vp.rePos.enabled ? normClamp( vp.rePos.normalizedX, 0.5 ) : 0.5,
                        nY = vp.rePos.enabled ? normClamp( vp.rePos.normalizedY, 0.0 ) : 0.0;
                 center( geometry.left() + qRound( nX * (double)geometry.width() ),
                         geometry.top() + qRound( nY * (double)geometry.height() ) );
                 // center() usually moves the viewport, that requests pixmaps too.
                 // if that doesn't happen we have to request them by hand
                 if ( prevX == horizontalScrollBar()->value() && prevY == verticalScrollBar()->value() )
                     slotRequestVisiblePixmaps();
             }
             // or else go to center page
             else
                 center( fullWidth / 2, 0 );
             viewport()->setUpdatesEnabled( true );
         }
     }
 
     // 5) update the whole viewport if updated enabled
     if ( wasUpdatesEnabled )
         viewport()->update();
 }
 
 void PageView::delayedResizeEvent()
 {
     // If we already got here we don't need to execute the timer slot again
     d->delayResizeEventTimer->stop();
     slotRelayoutPages();
     slotRequestVisiblePixmaps();
 }
 
-void PageView::slotRequestPreloadPixmap( Okular::DocumentObserver * observer, const PageViewItem * i, const QRect &expandedViewportRect, QLinkedList< Okular::PixmapRequest * > *requestedPixmaps )
+static void slotRequestPreloadPixmap( Okular::DocumentObserver * observer, const PageViewItem * i, const QRect &expandedViewportRect, QLinkedList< Okular::PixmapRequest * > *requestedPixmaps )
 {
     Okular::NormalizedRect preRenderRegion;
     const QRect intersectionRect = expandedViewportRect.intersected( i->croppedGeometry() );
     if ( !intersectionRect.isEmpty() )
         preRenderRegion = Okular::NormalizedRect( intersectionRect.translated( -i->uncroppedGeometry().topLeft() ), i->uncroppedWidth(), i->uncroppedHeight() );
 
     // request the pixmap if not already present
     if ( !i->page()->hasPixmap( observer, i->uncroppedWidth(), i->uncroppedHeight(), preRenderRegion ) && i->uncroppedWidth() > 0 )
     {
         Okular::PixmapRequest::PixmapRequestFeatures requestFeatures = Okular::PixmapRequest::Preload;
         requestFeatures |= Okular::PixmapRequest::Asynchronous;
         const bool pageHasTilesManager = i->page()->hasTilesManager( observer );
         if ( pageHasTilesManager && !preRenderRegion.isNull() )
         {
-            Okular::PixmapRequest * p = new Okular::PixmapRequest( observer, i->pageNumber(), i->uncroppedWidth(), i->uncroppedHeight(), devicePixelRatioF(), PAGEVIEW_PRELOAD_PRIO, requestFeatures );
+            Okular::PixmapRequest * p = new Okular::PixmapRequest( observer, i->pageNumber(), i->uncroppedWidth(), i->uncroppedHeight(), PAGEVIEW_PRELOAD_PRIO, requestFeatures );
             requestedPixmaps->push_back( p );
 
             p->setNormalizedRect( preRenderRegion );
             p->setTile( true );
         }
         else if ( !pageHasTilesManager )
         {
-            Okular::PixmapRequest * p = new Okular::PixmapRequest( observer, i->pageNumber(), i->uncroppedWidth(), i->uncroppedHeight(), devicePixelRatioF(), PAGEVIEW_PRELOAD_PRIO, requestFeatures );
+            Okular::PixmapRequest * p = new Okular::PixmapRequest( observer, i->pageNumber(), i->uncroppedWidth(), i->uncroppedHeight(), PAGEVIEW_PRELOAD_PRIO, requestFeatures );
             requestedPixmaps->push_back( p );
             p->setNormalizedRect( preRenderRegion );
         }
     }
 }
 
 void PageView::slotRequestVisiblePixmaps( int newValue )
 {
     // if requests are blocked (because raised by an unwanted event), exit
     if ( d->blockPixmapsRequest || d->viewportMoveActive )
         return;
 
     // precalc view limits for intersecting with page coords inside the loop
     const bool isEvent = newValue != -1 && !d->blockViewport;
     const QRect viewportRect( horizontalScrollBar()->value(),
                               verticalScrollBar()->value(),
                               viewport()->width(), viewport()->height() );
     const QRect viewportRectAtZeroZero( 0, 0, viewport()->width(), viewport()->height() );
 
     // some variables used to determine the viewport
     int nearPageNumber = -1;
     const double viewportCenterX = (viewportRect.left() + viewportRect.right()) / 2.0;
     const double viewportCenterY = (viewportRect.top() + viewportRect.bottom()) / 2.0;
     double focusedX = 0.5,
            focusedY = 0.0,
            minDistance = -1.0;
     // Margin (in pixels) around the viewport to preload
     const int pixelsToExpand = 512;
 
     // iterate over all items
     d->visibleItems.clear();
     QLinkedList< Okular::PixmapRequest * > requestedPixmaps;
     QVector< Okular::VisiblePageRect * > visibleRects;
     QVector< PageViewItem * >::const_iterator iIt = d->items.constBegin(), iEnd = d->items.constEnd();
     for ( ; iIt != iEnd; ++iIt )
     {
         PageViewItem * i = *iIt;
         foreach( FormWidgetIface *fwi, i->formWidgets() )
         {
             Okular::NormalizedRect r = fwi->rect();
             fwi->moveTo(
                 qRound( i->uncroppedGeometry().left() + i->uncroppedWidth() * r.left ) + 1 - viewportRect.left(),
                 qRound( i->uncroppedGeometry().top() + i->uncroppedHeight() * r.top ) + 1 - viewportRect.top() );
         }
         Q_FOREACH ( VideoWidget *vw, i->videoWidgets() )
         {
             const Okular::NormalizedRect r = vw->normGeometry();
             vw->move(
                 qRound( i->uncroppedGeometry().left() + i->uncroppedWidth() * r.left ) + 1 - viewportRect.left(),
                 qRound( i->uncroppedGeometry().top() + i->uncroppedHeight() * r.top ) + 1 - viewportRect.top() );
 
             if ( vw->isPlaying() && viewportRectAtZeroZero.intersected( vw->geometry() ).isEmpty() ) {
                 vw->stop();
                 vw->pageLeft();
             }
         }
 
         if ( !i->isVisible() )
             continue;
 #ifdef PAGEVIEW_DEBUG
         kWarning() << "checking page" << i->pageNumber();
         kWarning().nospace() << "viewportRect is " << viewportRect << ", page item is " << i->croppedGeometry() << " intersect : " << viewportRect.intersects( i->croppedGeometry() );
 #endif
         // if the item doesn't intersect the viewport, skip it
         QRect intersectionRect = viewportRect.intersected( i->croppedGeometry() );
         if ( intersectionRect.isEmpty() )
         {
             continue;
         }
 
         // add the item to the 'visible list'
         d->visibleItems.push_back( i );
         Okular::VisiblePageRect * vItem = new Okular::VisiblePageRect( i->pageNumber(), Okular::NormalizedRect( intersectionRect.translated( -i->uncroppedGeometry().topLeft() ), i->uncroppedWidth(), i->uncroppedHeight() ) );
         visibleRects.push_back( vItem );
 #ifdef PAGEVIEW_DEBUG
         kWarning() << "checking for pixmap for page" << i->pageNumber() << "=" << i->page()->hasPixmap( this, i->uncroppedWidth(), i->uncroppedHeight() );
         kWarning() << "checking for text for page" << i->pageNumber() << "=" << i->page()->hasTextPage();
 #endif
 
         Okular::NormalizedRect expandedVisibleRect = vItem->rect;
         if ( i->page()->hasTilesManager( this ) && Okular::Settings::memoryLevel() != Okular::Settings::EnumMemoryLevel::Low )
         {
             double rectMargin = pixelsToExpand/(double)i->uncroppedHeight();
             expandedVisibleRect.left = qMax( 0.0, vItem->rect.left - rectMargin );
             expandedVisibleRect.top = qMax( 0.0, vItem->rect.top - rectMargin );
             expandedVisibleRect.right = qMin( 1.0, vItem->rect.right + rectMargin );
             expandedVisibleRect.bottom = qMin( 1.0, vItem->rect.bottom + rectMargin );
         }
 
         // if the item has not the right pixmap, add a request for it
         if ( !i->page()->hasPixmap( this, i->uncroppedWidth(), i->uncroppedHeight(), expandedVisibleRect ) )
         {
 #ifdef PAGEVIEW_DEBUG
             kWarning() << "rerequesting visible pixmaps for page" << i->pageNumber() << "!";
 #endif
-            Okular::PixmapRequest * p = new Okular::PixmapRequest( this, i->pageNumber(), i->uncroppedWidth(), i->uncroppedHeight(), devicePixelRatioF(), PAGEVIEW_PRIO, Okular::PixmapRequest::Asynchronous );
+            Okular::PixmapRequest * p = new Okular::PixmapRequest( this, i->pageNumber(), i->uncroppedWidth(), i->uncroppedHeight(), PAGEVIEW_PRIO, Okular::PixmapRequest::Asynchronous );
             requestedPixmaps.push_back( p );
 
             if ( i->page()->hasTilesManager( this ) )
             {
                 p->setNormalizedRect( expandedVisibleRect );
                 p->setTile( true );
             }
             else
                 p->setNormalizedRect( vItem->rect );
         }
 
         // look for the item closest to viewport center and the relative
         // position between the item and the viewport center
         if ( isEvent )
         {
             const QRect & geometry = i->croppedGeometry();
             // compute distance between item center and viewport center (slightly moved left)
             double distance = hypot( (geometry.left() + geometry.right()) / 2 - (viewportCenterX - 4),
                                      (geometry.top() + geometry.bottom()) / 2 - viewportCenterY );
             if ( distance >= minDistance && nearPageNumber != -1 )
                 continue;
             nearPageNumber = i->pageNumber();
             minDistance = distance;
             if ( geometry.height() > 0 && geometry.width() > 0 )
             {
                 focusedX = ( viewportCenterX - (double)geometry.left() ) / (double)geometry.width();
                 focusedY = ( viewportCenterY - (double)geometry.top() ) / (double)geometry.height();
             }
         }
     }
 
     // if preloading is enabled, add the pages before and after in preloading
     if ( !d->visibleItems.isEmpty() &&
          Okular::SettingsCore::memoryLevel() != Okular::SettingsCore::EnumMemoryLevel::Low )
     {
         // as the requests are done in the order as they appear in the list,
         // request first the next page and then the previous
 
         int pagesToPreload = viewColumns();
 
         // if the greedy option is set, preload all pages
         if (Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Greedy)
             pagesToPreload = d->items.count();
 
         const QRect expandedViewportRect = viewportRect.adjusted( 0, -pixelsToExpand, 0, pixelsToExpand );
 
         for( int j = 1; j <= pagesToPreload; j++ )
         {
             // add the page after the 'visible series' in preload
             const int tailRequest = d->visibleItems.last()->pageNumber() + j;
             if ( tailRequest < (int)d->items.count() )
             {
                 slotRequestPreloadPixmap( this, d->items[ tailRequest ], expandedViewportRect, &requestedPixmaps );
             }
 
             // add the page before the 'visible series' in preload
             const int headRequest = d->visibleItems.first()->pageNumber() - j;
             if ( headRequest >= 0 )
             {
                 slotRequestPreloadPixmap( this, d->items[ headRequest ], expandedViewportRect, &requestedPixmaps );
             }
 
             // stop if we've already reached both ends of the document
             if ( headRequest < 0 && tailRequest >= (int)d->items.count() )
                 break;
         }
     }
 
     // send requests to the document
     if ( !requestedPixmaps.isEmpty() )
     {
         d->document->requestPixmaps( requestedPixmaps );
     }
     // if this functions was invoked by viewport events, send update to document
     if ( isEvent && nearPageNumber != -1 )
     {
         // determine the document viewport
         Okular::DocumentViewport newViewport( nearPageNumber );
         newViewport.rePos.enabled = true;
         newViewport.rePos.normalizedX = focusedX;
         newViewport.rePos.normalizedY = focusedY;
         // set the viewport to other observers
         d->document->setViewport( newViewport , this );
     }
     d->document->setVisiblePageRects( visibleRects, this );
 }
 
 void PageView::slotMoveViewport()
 {
     // converge to viewportMoveDest in 1 second
     int diffTime = d->viewportMoveTime.elapsed();
     if ( diffTime >= 667 || !d->viewportMoveActive )
     {
         center( d->viewportMoveDest.x(), d->viewportMoveDest.y() );
         d->viewportMoveTimer->stop();
         d->viewportMoveActive = false;
         slotRequestVisiblePixmaps();
         verticalScrollBar()->setEnabled( true );
         horizontalScrollBar()->setEnabled( true );
         return;
     }
 
     // move the viewport smoothly (kmplot: p(x)=1+0.47*(x-1)^3-0.25*(x-1)^4)
     float convergeSpeed = (float)diffTime / 667.0,
           x = ((float)viewport()->width() / 2.0) + horizontalScrollBar()->value(),
           y = ((float)viewport()->height() / 2.0) + verticalScrollBar()->value(),
           diffX = (float)d->viewportMoveDest.x() - x,
           diffY = (float)d->viewportMoveDest.y() - y;
     convergeSpeed *= convergeSpeed * (1.4 - convergeSpeed);
     center( (int)(x + diffX * convergeSpeed),
             (int)(y + diffY * convergeSpeed ) );
 }
 
 void PageView::slotAutoScroll()
 {
     // the first time create the timer
     if ( !d->autoScrollTimer )
     {
         d->autoScrollTimer = new QTimer( this );
         d->autoScrollTimer->setSingleShot( true );
         connect( d->autoScrollTimer, &QTimer::timeout, this, &PageView::slotAutoScroll );
     }
 
     // if scrollIncrement is zero, stop the timer
     if ( !d->scrollIncrement )
     {
         d->autoScrollTimer->stop();
         return;
     }
 
     // compute delay between timer ticks and scroll amount per tick
     int index = abs( d->scrollIncrement ) - 1;  // 0..9
     const int scrollDelay[10] =  { 200, 100, 50, 30, 20, 30, 25, 20, 30, 20 };
     const int scrollOffset[10] = {   1,   1,  1,  1,  1,  2,  2,  2,  4,  4 };
     d->autoScrollTimer->start( scrollDelay[ index ] );
     int delta = d->scrollIncrement > 0 ? scrollOffset[ index ] : -scrollOffset[ index ];
     verticalScrollBar()->setValue(verticalScrollBar()->value() + delta);
 }
 
 void PageView::slotDragScroll()
 {
     scrollTo( horizontalScrollBar()->value() + d->dragScrollVector.x(), verticalScrollBar()->value() + d->dragScrollVector.y() );
     QPoint p = contentAreaPosition() + viewport()->mapFromGlobal( QCursor::pos() );
     updateSelection( p );
 }
 
 void PageView::slotShowWelcome()
 {
     // show initial welcome text
     d->messageWindow->display( i18n( "Welcome" ), QString(), PageViewMessage::Info, 2000 );
 }
 
 void PageView::slotShowSizeAllCursor()
 {
     setCursor( Qt::SizeAllCursor );
 }
 
 void PageView::slotHandleWebShortcutAction()
 {
     QAction *action = qobject_cast<QAction*>( sender() );
 
     if (action) {
         KUriFilterData filterData( action->data().toString() );
 
         if ( KUriFilter::self()->filterSearchUri( filterData, KUriFilter::WebShortcutFilter ) ) {
             QDesktopServices::openUrl( filterData.uri() );
         }
     }
 }
 
 void PageView::slotConfigureWebShortcuts()
 {
     KToolInvocation::kdeinitExec( QStringLiteral("kcmshell5"), QStringList() << QStringLiteral("webshortcuts") );
 }
 
 void PageView::slotZoom()
 {
     if ( !d->aZoom->selectableActionGroup()->isEnabled() )
         return;
 
     setFocus();
     updateZoom( ZoomFixed );
 }
 
 void PageView::slotZoomIn()
 {
     updateZoom( ZoomIn );
 }
 
 void PageView::slotZoomOut()
 {
     updateZoom( ZoomOut );
 }
 
 void PageView::slotFitToWidthToggled( bool on )
 {
     if ( on ) updateZoom( ZoomFitWidth );
 }
 
 void PageView::slotFitToPageToggled( bool on )
 {
     if ( on ) updateZoom( ZoomFitPage );
 }
 
 void PageView::slotAutoFitToggled( bool on )
 {
     if ( on ) updateZoom( ZoomFitAuto );
 }
 
 void PageView::slotViewMode( QAction *action )
 {
     const int nr = action->data().toInt();
     if ( (int)Okular::Settings::viewMode() != nr )
     {
         Okular::Settings::setViewMode( nr );
         Okular::Settings::self()->save();
         if ( d->document->pages() > 0 )
             slotRelayoutPages();
     }
 }
 
 void PageView::slotContinuousToggled( bool on )
 {
     if ( Okular::Settings::viewContinuous() != on )
     {
         Okular::Settings::setViewContinuous( on );
         Okular::Settings::self()->save();
         if ( d->document->pages() > 0 )
             slotRelayoutPages();
     }
 }
 
 void PageView::slotSetMouseNormal()
 {
     d->mouseMode = Okular::Settings::EnumMouseMode::Browse;
     Okular::Settings::setMouseMode( d->mouseMode );
     // hide the messageWindow
     d->messageWindow->hide();
     // reshow the annotator toolbar if hiding was forced (and if it is not already visible)
     if ( d->annotator && d->annotator->hidingWasForced() && d->aToggleAnnotator && !d->aToggleAnnotator->isChecked() )
         d->aToggleAnnotator->trigger();
     // force an update of the cursor
     updateCursor();
     Okular::Settings::self()->save();
 }
 
 void PageView::slotSetMouseZoom()
 {
     d->mouseMode = Okular::Settings::EnumMouseMode::Zoom;
     Okular::Settings::setMouseMode( d->mouseMode );
     // change the text in messageWindow (and show it if hidden)
     d->messageWindow->display( i18n( "Select zooming area. Right-click to zoom out." ), QString(), PageViewMessage::Info, -1 );
     // force hiding of annotator toolbar
     if ( d->aToggleAnnotator && d->aToggleAnnotator->isChecked() )
     {
         d->aToggleAnnotator->trigger();
         d->annotator->setHidingForced( true );
     }
     // force an update of the cursor
     updateCursor();
     Okular::Settings::self()->save();
 }
 
 void PageView::slotSetMouseMagnifier()
 {
     d->mouseMode = Okular::Settings::EnumMouseMode::Magnifier;
     Okular::Settings::setMouseMode( d->mouseMode );
     d->messageWindow->display( i18n( "Click to see the magnified view." ), QString() );
 
     // force an update of the cursor
     updateCursor();
     Okular::Settings::self()->save();
 }
 
 void PageView::slotSetMouseSelect()
 {
     d->mouseMode = Okular::Settings::EnumMouseMode::RectSelect;
     Okular::Settings::setMouseMode( d->mouseMode );
     // change the text in messageWindow (and show it if hidden)
     d->messageWindow->display( i18n( "Draw a rectangle around the text/graphics to copy." ), QString(), PageViewMessage::Info, -1 );
     // force hiding of annotator toolbar
     if ( d->aToggleAnnotator && d->aToggleAnnotator->isChecked() )
     {
         d->aToggleAnnotator->trigger();
         d->annotator->setHidingForced( true );
     }
     // force an update of the cursor
     updateCursor();
     Okular::Settings::self()->save();
 }
 
 void PageView::slotSetMouseTextSelect()
 {
     d->mouseMode = Okular::Settings::EnumMouseMode::TextSelect;
     Okular::Settings::setMouseMode( d->mouseMode );
     // change the text in messageWindow (and show it if hidden)
     d->messageWindow->display( i18n( "Select text" ), QString(), PageViewMessage::Info, -1 );
     // force hiding of annotator toolbar
     if ( d->aToggleAnnotator && d->aToggleAnnotator->isChecked() )
     {
         d->aToggleAnnotator->trigger();
         d->annotator->setHidingForced( true );
     }
     // force an update of the cursor
     updateCursor();
     Okular::Settings::self()->save();
 }
 
 void PageView::slotSetMouseTableSelect()
 {
     d->mouseMode = Okular::Settings::EnumMouseMode::TableSelect;
     Okular::Settings::setMouseMode( d->mouseMode );
     // change the text in messageWindow (and show it if hidden)
     d->messageWindow->display( i18n(
         "Draw a rectangle around the table, then click near edges to divide up; press Esc to clear."
         ), QString(), PageViewMessage::Info, -1 );
     // force hiding of annotator toolbar
     if ( d->aToggleAnnotator && d->aToggleAnnotator->isChecked() )
     {
         d->aToggleAnnotator->trigger();
         d->annotator->setHidingForced( true );
     }
     // force an update of the cursor
     updateCursor();
     Okular::Settings::self()->save();
 }
 
 void PageView::slotToggleAnnotator( bool on )
 {
     // the 'inHere' trick is needed as the slotSetMouseZoom() calls this
     static bool inHere = false;
     if ( inHere )
         return;
     inHere = true;
 
     // the annotator can be used in normal mouse mode only, so if asked for it,
     // switch to normal mode
     if ( on && d->mouseMode != Okular::Settings::EnumMouseMode::Browse )
         d->aMouseNormal->trigger();
 
     // ask for Author's name if not already set
     if ( Okular::Settings::identityAuthor().isEmpty() )
     {
         // get default username from the kdelibs/kdecore/KUser
         KUser currentUser;
         QString userName = currentUser.property( KUser::FullName ).toString();
         // ask the user for confirmation/change
         if ( userName.isEmpty() )
         {
             bool ok = false;
             userName = QInputDialog::getText(0,
                            i18n( "Annotations author" ),
                            i18n( "Please insert your name or initials:" ),
                            QLineEdit::Normal,
                            QString(),
                            &ok );
 
             if ( !ok )
             {
                 d->aToggleAnnotator->trigger();
                 inHere = false;
                 return;
             }
         }
         // save the name
         Okular::Settings::setIdentityAuthor( userName );
         Okular::Settings::self()->save();
     }
 
     // create the annotator object if not present
     if ( !d->annotator )
     {
         d->annotator = new PageViewAnnotator( this, d->document );
         bool allowTools = d->document->pages() > 0 && d->document->isAllowed( Okular::AllowNotes );
         d->annotator->setToolsEnabled( allowTools );
         d->annotator->setTextToolsEnabled( allowTools && d->document->supportsSearching() );
     }
 
     // initialize/reset annotator (and show/hide toolbar)
     d->annotator->setEnabled( on );
     d->annotator->setHidingForced( false );
 
     inHere = false;
 }
 
 void PageView::slotAutoScrollUp()
 {
     if ( d->scrollIncrement < -9 )
         return;
     d->scrollIncrement--;
     slotAutoScroll();
     setFocus();
 }
 
 void PageView::slotAutoScrollDown()
 {
     if ( d->scrollIncrement > 9 )
         return;
     d->scrollIncrement++;
     slotAutoScroll();
     setFocus();
 }
 
 void PageView::slotScrollUp( bool singleStep )
 {
     // if in single page mode and at the top of the screen, go to \ page
     if ( Okular::Settings::viewContinuous() || verticalScrollBar()->value() > verticalScrollBar()->minimum() )
     {
         if ( singleStep )
             verticalScrollBar()->triggerAction( QScrollBar::SliderSingleStepSub );
         else
             verticalScrollBar()->triggerAction( QScrollBar::SliderPageStepSub );
     }
     else if ( d->document->currentPage() > 0 )
     {
         // more optimized than document->setPrevPage and then move view to bottom
         Okular::DocumentViewport newViewport = d->document->viewport();
         newViewport.pageNumber -= viewColumns();
         if ( newViewport.pageNumber < 0 )
             newViewport.pageNumber = 0;
         newViewport.rePos.enabled = true;
         newViewport.rePos.normalizedY = 1.0;
         d->document->setViewport( newViewport );
     }
 }
 
 void PageView::slotScrollDown( bool singleStep )
 {
     // if in single page mode and at the bottom of the screen, go to next page
     if ( Okular::Settings::viewContinuous() || verticalScrollBar()->value() < verticalScrollBar()->maximum() )
     {
         if ( singleStep )
             verticalScrollBar()->triggerAction( QScrollBar::SliderSingleStepAdd );
         else
             verticalScrollBar()->triggerAction( QScrollBar::SliderPageStepAdd );
     }
     else if ( (int)d->document->currentPage() < d->items.count() - 1 )
     {
         // more optimized than document->setNextPage and then move view to top
         Okular::DocumentViewport newViewport = d->document->viewport();
         newViewport.pageNumber += viewColumns();
         if ( newViewport.pageNumber >= (int)d->items.count() )
             newViewport.pageNumber = d->items.count() - 1;
         newViewport.rePos.enabled = true;
         newViewport.rePos.normalizedY = 0.0;
         d->document->setViewport( newViewport );
     }
 }
 
 void PageView::slotRotateClockwise()
 {
     int id = ( (int)d->document->rotation() + 1 ) % 4;
     d->document->setRotation( id );
 }
 
 void PageView::slotRotateCounterClockwise()
 {
     int id = ( (int)d->document->rotation() + 3 ) % 4;
     d->document->setRotation( id );
 }
 
 void PageView::slotRotateOriginal()
 {
     d->document->setRotation( 0 );
 }
 
 void PageView::slotPageSizes( int newsize )
 {
     if ( newsize < 0 || newsize >= d->document->pageSizes().count() )
         return;
 
     d->document->setPageSize( d->document->pageSizes().at( newsize ) );
 }
 
 // Enforce mutual-exclusion between trim modes
 // Each mode is uniquely identified by a single value
 // From Okular::Settings::EnumTrimMode
 void PageView::updateTrimMode( int except_id ) {
     const QList<QAction *> trimModeActions = d->aTrimMode->menu()->actions();
     foreach(QAction *trimModeAction, trimModeActions)
     {
         if (trimModeAction->data().toInt() != except_id)
             trimModeAction->setChecked( false );
     }
 }
 
 void PageView::slotTrimMarginsToggled( bool on )
 {
     if (on) { // Turn off any other Trim modes
        updateTrimMode(d->aTrimMargins->data().toInt());
     }
 
     if ( Okular::Settings::trimMargins() != on )
     {
         Okular::Settings::setTrimMargins( on );
         Okular::Settings::self()->save();
         if ( d->document->pages() > 0 )
         {
             slotRelayoutPages();
             slotRequestVisiblePixmaps(); // TODO: slotRelayoutPages() may have done this already!
         }
     }
 }
 
 void PageView::slotTrimToSelectionToggled( bool on )
 {
     if ( on ) { // Turn off any other Trim modes
         updateTrimMode(d->aTrimToSelection->data().toInt());
 
         d->mouseMode = Okular::Settings::EnumMouseMode::TrimSelect;
         // change the text in messageWindow (and show it if hidden)
         d->messageWindow->display( i18n( "Draw a rectangle around the page area you wish to keep visible" ), QString(), PageViewMessage::Info, -1 );
         // force hiding of annotator toolbar
         if ( d->aToggleAnnotator && d->aToggleAnnotator->isChecked() )
         {
            d->aToggleAnnotator->trigger();
            d->annotator->setHidingForced( true );
         }
         // force an update of the cursor
         updateCursor();
     } else {
 
         // toggled off while making selection
         if ( Okular::Settings::EnumMouseMode::TrimSelect == d->mouseMode ) {
             // clear widget selection and invalidate rect
             selectionClear();
 
             // When Trim selection bbox interaction is over, we should switch to another mousemode.
             if ( d->aPrevAction )
             {
                 d->aPrevAction->trigger();
                 d->aPrevAction = 0;
             } else {
                 d->aMouseNormal->trigger();
             }
         }
 
         d->trimBoundingBox = Okular::NormalizedRect(); // invalidate box
         if ( d->document->pages() > 0 )
         {
             slotRelayoutPages();
             slotRequestVisiblePixmaps(); // TODO: slotRelayoutPages() may have done this already!
         }
     }
 
 }
 
 void PageView::slotToggleForms()
 {
     toggleFormWidgets( !d->m_formsVisible );
 }
 
 void PageView::slotFormChanged( int pageNumber )
 {
     if ( !d->refreshTimer )
     {
         d->refreshTimer = new QTimer( this );
         d->refreshTimer->setSingleShot( true );
         connect( d->refreshTimer, &QTimer::timeout,
                  this, &PageView::slotRefreshPage );
     }
     d->refreshPages << pageNumber;
     int delay = 0;
     if ( d->m_formsVisible )
     {
         delay = 1000;
     }
     d->refreshTimer->start( delay );
 }
 
 void PageView::slotRefreshPage()
 {
     foreach(int req, d->refreshPages)
     {
         QMetaObject::invokeMethod( d->document, "refreshPixmaps", Qt::QueuedConnection,
                                    Q_ARG( int, req ) );
     }
     d->refreshPages.clear();
 }
 
 #ifdef HAVE_SPEECH
 void PageView::slotSpeakDocument()
 {
     QString text;
     QVector< PageViewItem * >::const_iterator it = d->items.constBegin(), itEnd = d->items.constEnd();
     for ( ; it < itEnd; ++it )
     {
         Okular::RegularAreaRect * area = textSelectionForItem( *it );
         text.append( (*it)->page()->text( area ) );
         text.append( '\n' );
         delete area;
     }
 
     d->tts()->say( text );
 }
 
 void PageView::slotSpeakCurrentPage()
 {
     const int currentPage = d->document->viewport().pageNumber;
 
     PageViewItem *item = d->items.at( currentPage );
     Okular::RegularAreaRect * area = textSelectionForItem( item );
     const QString text = item->page()->text( area );
     delete area;
 
     d->tts()->say( text );
 }
 
 void PageView::slotStopSpeaks()
 {
     if ( !d->m_tts )
         return;
 
     d->m_tts->stopAllSpeechs();
 }
 #endif
 
 void PageView::slotAction( Okular::Action *action )
 {
     d->document->processAction( action );
 }
 
 void PageView::externalKeyPressEvent( QKeyEvent *e )
 {
     keyPressEvent( e );
 }
 
 void PageView::slotProcessMovieAction( const Okular::MovieAction *action )
 {
     const Okular::MovieAnnotation *movieAnnotation = action->annotation();
     if ( !movieAnnotation )
         return;
 
     Okular::Movie *movie = movieAnnotation->movie();
     if ( !movie )
         return;
 
     const int currentPage = d->document->viewport().pageNumber;
 
     PageViewItem *item = d->items.at( currentPage );
     if ( !item )
         return;
 
     VideoWidget *vw = item->videoWidgets().value( movie );
     if ( !vw )
         return;
 
     vw->show();
 
     switch ( action->operation() )
     {
         case Okular::MovieAction::Play:
             vw->stop();
             vw->play();
             break;
         case Okular::MovieAction::Stop:
             vw->stop();
             break;
         case Okular::MovieAction::Pause:
             vw->pause();
             break;
         case Okular::MovieAction::Resume:
             vw->play();
             break;
     };
 }
 
 void PageView::slotProcessRenditionAction( const Okular::RenditionAction *action )
 {
     Okular::Movie *movie = action->movie();
     if ( !movie )
         return;
 
     const int currentPage = d->document->viewport().pageNumber;
 
     PageViewItem *item = d->items.at( currentPage );
     if ( !item )
         return;
 
     VideoWidget *vw = item->videoWidgets().value( movie );
     if ( !vw )
         return;
 
     if ( action->operation() == Okular::RenditionAction::None )
         return;
 
     vw->show();
 
     switch ( action->operation() )
     {
         case Okular::RenditionAction::Play:
             vw->stop();
             vw->play();
             break;
         case Okular::RenditionAction::Stop:
             vw->stop();
             break;
         case Okular::RenditionAction::Pause:
             vw->pause();
             break;
         case Okular::RenditionAction::Resume:
             vw->play();
             break;
         default:
             return;
     };
 }
 
 void PageView::slotToggleChangeColors()
 {
     Okular::SettingsCore::setChangeColors( !Okular::SettingsCore::changeColors() );
     Okular::Settings::self()->save();
     viewport()->update();
 }
 
 void PageView::slotFitWindowToPage()
 {
-    const PageViewItem *currentPageItem;
+    PageViewItem currentPageItem = NULL;
     QSize viewportSize = viewport()->size();
     foreach ( const PageViewItem * pageItem, d->items )
     {
         if ( pageItem->isVisible() )
         {
-            currentPageItem = pageItem;
+            currentPageItem = *pageItem;
             break;
         }
     }
-    const QSize pageSize = QSize( currentPageItem->uncroppedWidth() + kcolWidthMargin, currentPageItem->uncroppedHeight() + krowHeightMargin );
+    const QSize pageSize = QSize( currentPageItem.uncroppedWidth() + kcolWidthMargin, currentPageItem.uncroppedHeight() + krowHeightMargin );
     if ( verticalScrollBar()->isVisible() )
         viewportSize.setWidth( viewportSize.width() + verticalScrollBar()->width() );
     if ( horizontalScrollBar()->isVisible() )
         viewportSize.setHeight( viewportSize.height() + horizontalScrollBar()->height() );
     emit fitWindowToPage( viewportSize, pageSize );
 }
 
 //END private SLOTS
 
 #include "moc_pageview.cpp"
 
 /* kate: replace-tabs on; indent-width 4; */
diff --git a/ui/pageview.h b/ui/pageview.h
index a211e14a6..b6cde3915 100644
--- a/ui/pageview.h
+++ b/ui/pageview.h
@@ -1,270 +1,269 @@
 /***************************************************************************
  *   Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>                  *
  *   Copyright (C) 2004 by Albert Astals Cid <aacid@kde.org>               *
  *                                                                         *
  *   With portions of code from kpdf/kpdf_pagewidget.h by:                 *
  *     Copyright (C) 2002 by Wilco Greven <greven@kde.org>                 *
  *     Copyright (C) 2003 by Christophe Devriese                           *
  *                           <Christophe.Devriese@student.kuleuven.ac.be>  *
  *     Copyright (C) 2003 by Laurent Montel <montel@kde.org>               *
  *     Copyright (C) 2003 by Kurt Pfeifle <kpfeifle@danka.de>              *
  *                                                                         *
  *   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 file follows coding style described in kdebase/kicker/HACKING
 
 #ifndef _OKULAR_PAGEVIEW_H_
 #define _OKULAR_PAGEVIEW_H_
 
 #include <qabstractscrollarea.h>
 #include <qlist.h>
 #include <qvector.h>
 #include "ui/pageviewutils.h"
 #include "core/area.h"
 #include "core/observer.h"
 #include "core/view.h"
 
 class KActionCollection;
 
 namespace Okular {
 class Action;
 class Document;
 class DocumentViewport;
 class Annotation;
 class MovieAction;
 class RenditionAction;
 class PixmapRequest;
 }
 
 class FormWidgetIface;
 class PageViewPrivate;
 
 class MagnifierView;
 
 class QGestureEvent;
 
 /**
  * @short The main view. Handles zoom and continuous mode.. oh, and page
  * @short display of course :-)
  * ...
  */
 class PageView : public QAbstractScrollArea, public Okular::DocumentObserver, public Okular::View
 {
 Q_OBJECT
 
     public:
         PageView( QWidget *parent, Okular::Document *document );
         ~PageView();
 
         // Zoom mode ( last 3 are internally used only! )
         enum ZoomMode { ZoomFixed = 0, ZoomFitWidth = 1, ZoomFitPage = 2, ZoomFitAuto = 3,
                         ZoomIn, ZoomOut, ZoomRefreshCurrent };
 
         enum ClearMode { ClearAllSelection, ClearOnlyDividers };
 
         // create actions that interact with this widget
         void setupBaseActions( KActionCollection * collection );
         void setupViewerActions( KActionCollection * collection );
         void setupActions( KActionCollection * collection );
         void updateActionState( bool docHasPages, bool docChanged, bool docHasFormWidgets );
 
         // misc methods (from RMB menu/children)
         bool canFitPageWidth() const;
         void fitPageWidth( int page );
         // keep in sync with pageviewutils
         void displayMessage( const QString & message, const QString & details = QString(), PageViewMessage::Icon icon=PageViewMessage::Info, int duration=-1 );
 
         // inherited from DocumentObserver
         void notifySetup( const QVector< Okular::Page * > & pages, int setupFlags ) override;
         void notifyViewportChanged( bool smoothMove ) override;
         void notifyPageChanged( int pageNumber, int changedFlags ) override;
         void notifyContentsCleared( int changedFlags ) override;
         void notifyZoom(int factor) override;
         bool canUnloadPixmap( int pageNum ) const override;
         void notifyCurrentPageChanged( int previous, int current ) override;
 
         // inherited from View
         bool supportsCapability( ViewCapability capability ) const override;
         CapabilityFlags capabilityFlags( ViewCapability capability ) const override;
         QVariant capability( ViewCapability capability ) const override;
         void setCapability( ViewCapability capability, const QVariant &option ) override;
 
         QList< Okular::RegularAreaRect * > textSelections( const QPoint& start, const QPoint& end, int& firstpage );
         Okular::RegularAreaRect * textSelectionForItem( PageViewItem * item, const QPoint & startPoint = QPoint(), const QPoint & endPoint = QPoint() );
 
         void reparseConfig();
 
         KActionCollection *actionCollection() const;
         QAction *toggleFormsAction() const;
 
         int contentAreaWidth() const;
         int contentAreaHeight() const;
         QPoint contentAreaPosition() const;
         QPoint contentAreaPoint( const QPoint & pos ) const;
         QPointF contentAreaPoint( const QPointF & pos ) const;
 
         bool areSourceLocationsShownGraphically() const;
         void setShowSourceLocationsGraphically(bool show);
 
         void setLastSourceLocationViewport( const Okular::DocumentViewport& vp );
         void clearLastSourceLocationViewport();
 
         void updateCursor();
 
     public Q_SLOTS:
         void copyTextSelection() const;
         void selectAll();
 
         void openAnnotationWindow( Okular::Annotation *annotation, int pageNumber );
         void reloadForms();
 
     Q_SIGNALS:
         void rightClick( const Okular::Page *, const QPoint & );
         void mouseBackButtonClick();
         void mouseForwardButtonClick();
         void escPressed();
         void fitWindowToPage( const QSize& pageViewPortSize, const QSize& pageSize );
 
     protected:
         bool event( QEvent * event ) override;
 
         void resizeEvent( QResizeEvent* ) override;
         bool gestureEvent( QGestureEvent * e );
 
         // mouse / keyboard events
         void keyPressEvent( QKeyEvent* ) override;
         void keyReleaseEvent( QKeyEvent* ) override;
         void inputMethodEvent( QInputMethodEvent * ) override;
         void wheelEvent( QWheelEvent* ) override;
 
         void paintEvent( QPaintEvent *e ) override;
         void tabletEvent (QTabletEvent *e ) override;
         void mouseMoveEvent( QMouseEvent *e ) override;
         void mousePressEvent( QMouseEvent *e ) override;
         void mouseReleaseEvent( QMouseEvent *e ) override;
         void mouseDoubleClickEvent( QMouseEvent *e ) override;
 
         bool viewportEvent( QEvent *e ) override;
 
         void scrollContentsBy( int dx, int dy ) override;
 
     private:
         // draw background and items on the opened qpainter
         void drawDocumentOnPainter( const QRect & pageViewRect, QPainter * p );
         // update item width and height using current zoom parameters
         void updateItemSize( PageViewItem * item, int columnWidth, int rowHeight );
         // return the widget placed on a certain point or 0 if clicking on empty space
         PageViewItem * pickItemOnPoint( int x, int y );
         // start / modify / clear selection rectangle
         void selectionStart( const QPoint & pos, const QColor & color, bool aboveAll = false );
         void selectionClear( const ClearMode mode = ClearAllSelection );
         void drawTableDividers(QPainter * screenPainter);
         void guessTableDividers();
         // update either text or rectangle selection
         void updateSelection( const QPoint & pos );
         // compute the zoom factor value for FitWidth and FitPage mode
         double zoomFactorFitMode( ZoomMode mode );
         // update internal zoom values and end in a slotRelayoutPages();
         void updateZoom( ZoomMode newZm );
         // update the text on the label using global zoom value or current page's one
         void updateZoomText();
         void textSelectionClear();
         // updates cursor
         void updateCursor( const QPoint &p );
 
         void moveMagnifier( const QPoint &p );
         void updateMagnifier( const QPoint &p );
 
         int viewColumns() const;
 
         void center(int cx, int cy);
         void scrollTo( int x, int y );
 
         void toggleFormWidgets( bool on );
 
         void resizeContentArea( const QSize & newSize );
         void updatePageStep();
 
         void addWebShortcutsMenu( QMenu * menu, const QString & text );
         // used when selecting stuff, makes the view scroll as necessary to keep the mouse inside the view
         void scrollPosIntoView( const QPoint & pos );
 
         // called from slots to turn off trim modes mutually exclusive to id
         void updateTrimMode( int except_id );
 
         // don't want to expose classes in here
         class PageViewPrivate * d;
 
     private Q_SLOTS:
         // used to decouple the notifyViewportChanged calle
         void slotRealNotifyViewportChanged(bool smoothMove);
         // activated either directly or via queued connection on notifySetup
         void slotRelayoutPages();
         // activated by the resize event delay timer
         void delayedResizeEvent();
         // activated either directly or via the contentsMoving(int,int) signal
         void slotRequestVisiblePixmaps( int newValue = -1 );
         // activated by the viewport move timer
         void slotMoveViewport();
         // activated by the autoscroll timer (Shift+Up/Down keys)
         void slotAutoScroll();
         // activated by the dragScroll timer
         void slotDragScroll();
         // show the welcome message
         void slotShowWelcome();
         // activated by left click timer
         void slotShowSizeAllCursor();
 
         void slotHandleWebShortcutAction();
         void slotConfigureWebShortcuts();
 
         // connected to local actions (toolbar, menu, ..)
         void slotZoom();
         void slotZoomIn();
         void slotZoomOut();
         void slotFitToWidthToggled( bool );
         void slotFitToPageToggled( bool );
         void slotAutoFitToggled( bool );
         void slotViewMode( QAction *action );
         void slotContinuousToggled( bool );
         void slotSetMouseNormal();
         void slotSetMouseZoom();
         void slotSetMouseMagnifier();
         void slotSetMouseSelect();
         void slotSetMouseTextSelect();
         void slotSetMouseTableSelect();
         void slotToggleAnnotator( bool );
         void slotAutoScrollUp();
         void slotAutoScrollDown();
         void slotScrollUp( bool singleStep = false );
         void slotScrollDown( bool singleStep = false );
         void slotRotateClockwise();
         void slotRotateCounterClockwise();
         void slotRotateOriginal();
         void slotPageSizes( int );
         void slotTrimMarginsToggled( bool );
         void slotTrimToSelectionToggled( bool );
         void slotToggleForms();
         void slotFormChanged( int pageNumber );
         void slotRefreshPage();
 #ifdef HAVE_SPEECH
         void slotSpeakDocument();
         void slotSpeakCurrentPage();
         void slotStopSpeaks();
 #endif
         void slotAction( Okular::Action *action );
         void externalKeyPressEvent( QKeyEvent *e );
         void slotAnnotationWindowDestroyed( QObject *window );
         void slotProcessMovieAction( const Okular::MovieAction *action );
         void slotProcessRenditionAction( const Okular::RenditionAction *action );
         void slotToggleChangeColors();
         void slotFitWindowToPage();
-        void slotRequestPreloadPixmap( Okular::DocumentObserver *observer, const PageViewItem *i, const QRect &expandedViewportRect, QLinkedList< Okular::PixmapRequest * > *requestedPixmaps );
 };
 
 #endif
 
 /* kate: replace-tabs on; indent-width 4; */
diff --git a/ui/pageviewutils.cpp b/ui/pageviewutils.cpp
index ad5b583d7..a57712ca2 100644
--- a/ui/pageviewutils.cpp
+++ b/ui/pageviewutils.cpp
@@ -1,946 +1,946 @@
 /***************************************************************************
  *   Copyright (C) 2004-2005 by Enrico Ros <eros.kde@email.it>             *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "pageviewutils.h"
 
 // qt/kde includes
 #include <qapplication.h>
 #include <qbitmap.h>
 #include <qbrush.h>
 #include <qimage.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpainter.h>
 #include <qevent.h>
 #include <qstyle.h>
 #include <qtimer.h>
 #include <qtoolbutton.h>
 #include <kacceleratormanager.h>
 #include <kactioncollection.h>
 #include <kcolorscheme.h>
 #include <kiconloader.h>
 #include <KLocalizedString>
 
 // system includes
 #include <math.h>
 
 // local includes
 #include "formwidgets.h"
 #include "pageview.h"
 #include "videowidget.h"
 #include "core/movie.h"
 #include "core/page.h"
 #include "core/form.h"
 #include "settings.h"
 
 /*********************/
 /** PageViewItem     */
 /*********************/
 
-PageViewItem::PageViewItem( const Okular::Page * page, qreal dpr )
-    : m_page( page ), m_dpr( dpr ), m_zoomFactor( 1.0 ), m_visible( true ),
+PageViewItem::PageViewItem( const Okular::Page * page )
+    : m_page( page ), m_zoomFactor( 1.0 ), m_visible( true ),
     m_formsVisible( false ), m_crop( 0., 0., 1., 1. )
 {
 }
 
 PageViewItem::~PageViewItem()
 {
     QHash<int, FormWidgetIface*>::iterator it = m_formWidgets.begin(), itEnd = m_formWidgets.end();
     for ( ; it != itEnd; ++it )
         delete *it;
     qDeleteAll( m_videoWidgets );
 }
 
 const Okular::Page * PageViewItem::page() const
 {
     return m_page;
 }
 
 int PageViewItem::pageNumber() const
 {
     return m_page->number();
 }
 
 const QRect& PageViewItem::croppedGeometry() const
 {
     return m_croppedGeometry;
 }
 
 int PageViewItem::croppedWidth() const
 {
     return m_croppedGeometry.width();
 }
 
 int PageViewItem::croppedHeight() const
 {
     return m_croppedGeometry.height();
 }
 
 const QRect& PageViewItem::uncroppedGeometry() const
 {
     return m_uncroppedGeometry;
 }
 
 int PageViewItem::uncroppedWidth() const
 {
     return m_uncroppedGeometry.width();
 }
 
 int PageViewItem::uncroppedHeight() const
 {
     return m_uncroppedGeometry.height();
 }
 
 const Okular::NormalizedRect & PageViewItem::crop() const
 {
     return m_crop;
 }
 
 double PageViewItem::zoomFactor() const
 {
     return m_zoomFactor;
 }
 
 double PageViewItem::absToPageX( double absX ) const
 {
     return ( absX - m_uncroppedGeometry.left() ) / m_uncroppedGeometry.width();
 }
 
 double PageViewItem::absToPageY( double absY ) const
 {
     return ( absY - m_uncroppedGeometry.top() ) / m_uncroppedGeometry.height();
 }
 
 bool PageViewItem::isVisible() const
 {
     return m_visible;
 }
 
 QHash<int, FormWidgetIface*>& PageViewItem::formWidgets()
 {
     return m_formWidgets;
 }
 
 QHash< Okular::Movie *, VideoWidget* >& PageViewItem::videoWidgets()
 {
     return m_videoWidgets;
 }
 
 void PageViewItem::setWHZC( int w, int h, double z, const Okular:: NormalizedRect & c )
 {
     m_croppedGeometry.setWidth( w );
     m_croppedGeometry.setHeight( h );
     m_zoomFactor = z;
     m_crop = c;
     m_uncroppedGeometry.setWidth( qRound( w / ( c.right - c.left ) ) );
     m_uncroppedGeometry.setHeight( qRound( h / ( c.bottom - c.top ) ) );
     foreach(FormWidgetIface *fwi, m_formWidgets)
     {
         Okular::NormalizedRect r = fwi->rect();
         fwi->setWidthHeight(
             qRound( fabs( r.right - r.left ) * m_uncroppedGeometry.width() ),
             qRound( fabs( r.bottom - r.top ) * m_uncroppedGeometry.height() ) );
     }
     Q_FOREACH ( VideoWidget *vw, m_videoWidgets )
     {
         const Okular::NormalizedRect r = vw->normGeometry();
         vw->resize(
             qRound( fabs( r.right - r.left ) * m_uncroppedGeometry.width() ),
             qRound( fabs( r.bottom - r.top ) * m_uncroppedGeometry.height() ) );
     }
 }
 
 void PageViewItem::moveTo( int x, int y )
 // Assumes setWHZC() has already been called
 {
     m_croppedGeometry.moveLeft( x );
     m_croppedGeometry.moveTop( y );
     m_uncroppedGeometry.moveLeft( qRound( x - m_crop.left * m_uncroppedGeometry.width() ) );
     m_uncroppedGeometry.moveTop( qRound( y - m_crop.top * m_uncroppedGeometry.height() ) );
     QHash<int, FormWidgetIface*>::iterator it = m_formWidgets.begin(), itEnd = m_formWidgets.end();
     for ( ; it != itEnd; ++it )
     {
         Okular::NormalizedRect r = (*it)->rect();
         (*it)->moveTo(
             qRound( x + m_uncroppedGeometry.width() * r.left ) + 1,
             qRound( y + m_uncroppedGeometry.height() * r.top ) + 1 );
     }
     Q_FOREACH ( VideoWidget *vw, m_videoWidgets )
     {
         const Okular::NormalizedRect r = vw->normGeometry();
         vw->move(
             qRound( x + m_uncroppedGeometry.width() * r.left ) + 1,
             qRound( y + m_uncroppedGeometry.height() * r.top ) + 1 );
     }
 }
 
 void PageViewItem::setVisible( bool visible )
 {
     setFormWidgetsVisible( visible && m_formsVisible );
     m_visible = visible;
 }
 
 void PageViewItem::invalidate()
 {
     m_croppedGeometry.setRect( 0, 0, 0, 0 );
     m_uncroppedGeometry.setRect( 0, 0, 0, 0 );
 }
 
 bool PageViewItem::setFormWidgetsVisible( bool visible )
 {
     m_formsVisible = visible;
 
     if ( !m_visible )
         return false;
 
     bool somehadfocus = false;
     QHash<int, FormWidgetIface*>::iterator it = m_formWidgets.begin(), itEnd = m_formWidgets.end();
     for ( ; it != itEnd; ++it )
     {
         bool hadfocus = (*it)->setVisibility( visible && (*it)->formField()->isVisible() );
         somehadfocus = somehadfocus || hadfocus;
     }
     return somehadfocus;
 }
 
 void PageViewItem::reloadFormWidgetsState()
 {
     foreach(FormWidgetIface *fwi, m_formWidgets)
     {
         fwi->setVisibility( fwi->formField()->isVisible() );
     }
 }
 
 /*********************/
 /** PageViewMessage  */
 /*********************/
 
 PageViewMessage::PageViewMessage( QWidget * parent )
     : QWidget( parent ), m_timer( 0 )
     , m_lineSpacing( 0 )
 {
     setObjectName( QStringLiteral( "pageViewMessage" ) );
     setFocusPolicy( Qt::NoFocus );
     QPalette pal = palette();
     pal.setColor( QPalette::Active, QPalette::Window, QApplication::palette().color( QPalette::Active, QPalette::Window ) );
     setPalette( pal );
     // if the layout is LtR, we can safely place it in the right position
     if ( layoutDirection() == Qt::LeftToRight )
         move( 10, 10 );
     resize( 0, 0 );
     hide();
 }
 
 void PageViewMessage::display( const QString & message, const QString & details, Icon icon, int durationMs )
 // give Caesar what belongs to Caesar: code taken from Amarok's osd.h/.cpp
 // "redde (reddite, pl.) cesari quae sunt cesaris", just btw.  :)
 // The code has been heavily modified since then.
 {
     if ( !Okular::Settings::showOSD() )
     {
         hide();
         return;
     }
 
     // set text
     m_message = message;
     m_details = details;
     // reset vars
     m_lineSpacing = 0;
 
     // load icon (if set)
     m_symbol = QPixmap();
     if ( icon != None )
     {
         switch ( icon )
         {
             case Annotation:
                 m_symbol = SmallIcon( QStringLiteral("draw-freehand") );
                 break;
             case Find:
                 m_symbol = SmallIcon( QStringLiteral("zoom-original") );
                 break;
             case Error:
                 m_symbol = SmallIcon( QStringLiteral("dialog-error") );
                 break;
             case Warning:
                 m_symbol = SmallIcon( QStringLiteral("dialog-warning") );
                 break;
             default:
                 m_symbol = SmallIcon( QStringLiteral("dialog-information") );
                 break;
         }
 
     }
 
     computeSizeAndResize();
     // show widget and schedule a repaint
     show();
     update();
 
     // close the message window after given mS
     if ( durationMs > 0 )
     {
         if ( !m_timer )
         {
             m_timer = new QTimer( this );
             m_timer->setSingleShot( true );
             connect(m_timer, &QTimer::timeout, this, &PageViewMessage::hide);
         }
         m_timer->start( durationMs );
     } else if ( m_timer )
         m_timer->stop();
 
     qobject_cast<QAbstractScrollArea*>(parentWidget())->viewport()->installEventFilter(this);
 
 }
 
 QRect PageViewMessage::computeTextRect( const QString & message, int extra_width ) const
 // Return the QRect which embeds the text
 {
     int charSize = fontMetrics().averageCharWidth();
     /* width of the viewport, minus 20 (~ size removed by further resizing),
        minus the extra size (usually the icon width), minus (a bit empirical)
        twice the mean width of a character to ensure that the bounding box is
        really smaller than the container.
      */
     const int boundingWidth = qobject_cast<QAbstractScrollArea*>(parentWidget())->viewport()->width() - 20 - ( extra_width > 0 ? 2 + extra_width : 0 ) - 2*charSize;
     QRect textRect = fontMetrics().boundingRect( 0, 0, boundingWidth, 0,
                      Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap, message );
     textRect.translate( -textRect.left(), -textRect.top() );
     textRect.adjust( 0, 0, 2, 2 );
 
     return textRect;
 }
 
 void PageViewMessage::computeSizeAndResize()
 {
     // determine text rectangle
     const QRect textRect = computeTextRect( m_message, m_symbol.width() );
     int width = textRect.width(),
         height = textRect.height();
 
     if ( !m_details.isEmpty() )
     {
         // determine details text rectangle
         const QRect detailsRect = computeTextRect( m_details, m_symbol.width() );
         width = qMax( width, detailsRect.width() );
         height += detailsRect.height();
 
         // plus add a ~60% line spacing
         m_lineSpacing = static_cast< int >( fontMetrics().height() * 0.6 );
         height += m_lineSpacing;
     }
 
     // update geometry with icon information
     if ( ! m_symbol.isNull() )
     {
         width += 2 + m_symbol.width();
         height = qMax( height, m_symbol.height() );
     }
 
     // resize widget
     resize( QRect( 0, 0, width + 10, height + 8 ).size() );
 
     // if the layout is RtL, we can move it to the right place only after we
     // know how much size it will take
     if ( layoutDirection() == Qt::RightToLeft )
         move( parentWidget()->width() - geometry().width() - 10 - 1, 10 );
 }
 
 
 bool PageViewMessage::eventFilter(QObject * obj, QEvent * event )
 {
     /* if the parent object (scroll area) resizes, the message should
        resize as well */
     if (event->type() == QEvent::Resize)
     {
         QResizeEvent *resizeEvent = static_cast<QResizeEvent *>(event);
         if ( resizeEvent->oldSize() != resizeEvent->size() )
         {
            computeSizeAndResize();
         }
     }
     // standard event processing
     return QObject::eventFilter(obj, event);
 }
 
 void PageViewMessage::paintEvent( QPaintEvent * /* e */ )
 {
     const QRect textRect = computeTextRect( m_message, m_symbol.width() );
 
     QRect detailsRect;
     if ( !m_details.isEmpty() )
     {
         detailsRect = computeTextRect( m_details, m_symbol.width() );
     }
 
     int textXOffset = 0,
         // add 2 to account for the reduced drawRoundRect later
         textYOffset = ( geometry().height() - textRect.height() - detailsRect.height() - m_lineSpacing + 2 ) / 2,
         iconXOffset = 0,
         iconYOffset = !m_symbol.isNull() ? ( geometry().height() - m_symbol.height() ) / 2 : 0,
         shadowOffset = 1;
 
     if ( layoutDirection() == Qt::RightToLeft )
         iconXOffset = 2 + textRect.width();
     else
         textXOffset = 2 + m_symbol.width();
 
     // draw background
     QPainter painter( this );
     painter.setRenderHint( QPainter::Antialiasing, true );
     painter.setPen( Qt::black );
     painter.setBrush( palette().color( QPalette::Window ) );
     painter.translate( 0.5, 0.5 );
     painter.drawRoundRect( 1, 1, width()-2, height()-2, 1600 / width(), 1600 / height() );
 
     // draw icon if present
     if ( !m_symbol.isNull() )
         painter.drawPixmap( 5 + iconXOffset, iconYOffset, m_symbol, 0, 0, m_symbol.width(), m_symbol.height() );
 
     const int xStartPoint = 5 + textXOffset;
     const int yStartPoint = textYOffset;
     const int textDrawingFlags = Qt::AlignLeft | Qt::AlignTop | Qt::TextWordWrap;
 
     // draw shadow and text
     painter.setPen( palette().color( QPalette::Window ).dark( 115 ) );
     painter.drawText( xStartPoint + shadowOffset, yStartPoint + shadowOffset, textRect.width(), textRect.height(), textDrawingFlags, m_message );
     if ( !m_details.isEmpty() )
         painter.drawText( xStartPoint + shadowOffset, yStartPoint + textRect.height() + m_lineSpacing + shadowOffset, textRect.width(), detailsRect.height(), textDrawingFlags, m_details );
     painter.setPen( palette().color( QPalette::WindowText ) );
     painter.drawText( xStartPoint, yStartPoint, textRect.width(), textRect.height(), textDrawingFlags, m_message );
     if ( !m_details.isEmpty() )
         painter.drawText( xStartPoint + shadowOffset, yStartPoint + textRect.height() + m_lineSpacing, textRect.width(), detailsRect.height(), textDrawingFlags, m_details );
 }
 
 void PageViewMessage::mousePressEvent( QMouseEvent * /*e*/ )
 {
     if ( m_timer )
         m_timer->stop();
     hide();
 }
 
 
 /*********************/
 /** PageViewToolBar  */
 /*********************/
 
 ToolBarButton::ToolBarButton( QWidget * parent, const AnnotationToolItem &item )
     : QToolButton( parent ), m_id( item.id ), m_isText( item.isText )
 {
     setCheckable( true );
     setAutoRaise( true );
     resize( buttonSize, buttonSize );
     setIconSize( QSize( iconSize, iconSize ) );
     setIcon( QIcon( item.pixmap ) );
     // set shortcut if defined
     if ( !item.shortcut.isEmpty() )
         setShortcut( QKeySequence( item.shortcut ) );
     else
         KAcceleratorManager::setNoAccel( this );
 
     // if accel is set display it along name
     QString accelString = shortcut().toString( QKeySequence::NativeText );
     if ( !accelString.isEmpty() )
         setToolTip( QStringLiteral("%1 [%2]").arg( item.text, accelString ) );
     else
         setToolTip( item.text );
 }
 
 void ToolBarButton::mouseDoubleClickEvent( QMouseEvent * /*event*/ )
 {
   emit buttonDoubleClicked( buttonID() );
 }
 
 /* PageViewToolBar */
 
 static const int toolBarGridSize = 40;
 
 class ToolBarPrivate
 {
 public:
     ToolBarPrivate( PageViewToolBar * qq )
         : q( qq )
     {
     }
 
     // rebuild contents and reposition then widget
     void buildToolBar();
     void reposition();
     // compute the visible and hidden positions along current side
     QPoint getInnerPoint() const;
     QPoint getOuterPoint() const;
     void selectButton( ToolBarButton * button );
 
     PageViewToolBar * q;
 
     // anchored widget and side
     QWidget * anchorWidget;
     PageViewToolBar::Side anchorSide;
 
     // slide in/out stuff
     QTimer * animTimer;
     QPoint currentPosition;
     QPoint endPosition;
     bool hiding;
     bool visible;
 
     // background pixmap and buttons
     QPixmap backgroundPixmap;
     QLinkedList< ToolBarButton * > buttons;
 };
 
 PageViewToolBar::PageViewToolBar( PageView * parent, QWidget * anchorWidget )
     : QWidget( parent ), d( new ToolBarPrivate( this ) )
 {
     // initialize values of the private data storage structure
     d->anchorWidget = anchorWidget;
     d->anchorSide = Left;
     d->hiding = false;
     d->visible = false;
 
     // create the animation timer
     d->animTimer = new QTimer( this );
     connect( d->animTimer, &QTimer::timeout, this, &PageViewToolBar::slotAnimate );
 
     // apply a filter to get notified when anchor changes geometry
     d->anchorWidget->installEventFilter( this );
 
     setContextMenuPolicy( Qt::ActionsContextMenu );
     addAction( parent->actionCollection()->action( QStringLiteral("options_configure_annotations") ) );
 }
 
 PageViewToolBar::~PageViewToolBar()
 {
     // delete the private data storage structure
     delete d;
 }
 
 void PageViewToolBar::setItems( const QLinkedList<AnnotationToolItem> &items )
 {
     // delete buttons if already present
     if ( !d->buttons.isEmpty() )
     {
         QLinkedList< ToolBarButton * >::iterator it = d->buttons.begin(), end = d->buttons.end();
         for ( ; it != end; ++it )
             delete *it;
         d->buttons.clear();
     }
 
     // create new buttons for given items
     QLinkedList<AnnotationToolItem>::const_iterator it = items.begin(), end = items.end();
     for ( ; it != end; ++it )
     {
         ToolBarButton * button = new ToolBarButton( this, *it );
         connect(button, &ToolBarButton::clicked, this, &PageViewToolBar::slotButtonClicked);
         connect(button, &ToolBarButton::buttonDoubleClicked, this, &PageViewToolBar::buttonDoubleClicked);
         d->buttons.append( button );
     }
 
     // rebuild toolbar shape and contents
     d->reposition();
 }
 
 void PageViewToolBar::setSide( Side side )
 {
     d->anchorSide = side;
 
     d->reposition();
 }
 
 void PageViewToolBar::showAndAnimate()
 {
     // set parameters for sliding in
     d->hiding = false;
 
     show();
 
 #ifdef OKULAR_ANIMATE_REVIEW_TOOBAR
     // start scrolling in
     d->animTimer->start( 20 );
 #else
     d->currentPosition = d->endPosition;
 
     move( d->currentPosition );
 
     d->visible = true;
 #endif
 }
 
 void PageViewToolBar::hideAndDestroy()
 {
     // set parameters for sliding out
     d->hiding = true;
     d->endPosition = d->getOuterPoint();
 
 #ifdef OKULAR_ANIMATE_REVIEW_TOOBAR
     // start scrolling out
     d->animTimer->start( 20 );
 #else
     d->currentPosition = d->endPosition;
 
     move( d->currentPosition );
 
     d->visible = false;
     deleteLater();
 #endif
 }
 
 void PageViewToolBar::selectButton( int id )
 {
     ToolBarButton * button = 0;
     if ( id >= 0 && id < d->buttons.count() )
         button = *(d->buttons.begin() + id);
     else
     {
         QLinkedList< ToolBarButton * >::const_iterator it = d->buttons.begin(), end = d->buttons.end();
         for ( ; !button && it != end; ++it )
             if ( (*it)->isChecked() )
                 button = *it;
         if ( button )
             button->setChecked( false );
     }
     d->selectButton( button );
 }
 
 bool PageViewToolBar::eventFilter( QObject * obj, QEvent * e )
 {
     // if anchorWidget changed geometry reposition toolbar
     if ( obj == d->anchorWidget && e->type() == QEvent::Resize )
     {
         d->animTimer->stop();
         if ( d->hiding )
             deleteLater();
         else
             d->reposition();
     }
 
     // don't block event
     return false;
 }
 
 void PageViewToolBar::paintEvent( QPaintEvent * e )
 {
     // paint the internal pixmap over the widget
     QPainter p( this );
     p.drawImage( e->rect().topLeft(), d->backgroundPixmap.toImage(), e->rect() );
 }
 
 void PageViewToolBar::mousePressEvent( QMouseEvent * e )
 {
     // set 'dragging' cursor
     if ( e->button() == Qt::LeftButton )
         setCursor( Qt::SizeAllCursor );
 }
 
 void PageViewToolBar::mouseMoveEvent( QMouseEvent * e )
 {
     if ( ( QApplication::mouseButtons() & Qt::LeftButton ) != Qt::LeftButton )
         return;
 
     // compute the nearest side to attach the widget to
     QPoint parentPos = mapToParent( e->pos() );
     float nX = (float)parentPos.x() / (float)d->anchorWidget->width(),
           nY = (float)parentPos.y() / (float)d->anchorWidget->height();
     if ( nX > 0.3 && nX < 0.7 && nY > 0.3 && nY < 0.7 )
         return;
     bool LT = nX < (1.0 - nY);
     bool LB = nX < (nY);
     Side side = LT ? ( LB ? Left : Top ) : ( LB ? Bottom : Right );
 
     // check if side changed
     if ( side == d->anchorSide )
         return;
 
     d->anchorSide = side;
     d->reposition();
     emit orientationChanged( (int)side );
 }
 
 void PageViewToolBar::mouseReleaseEvent( QMouseEvent * e )
 {
     // set normal cursor
     if ( e->button() == Qt::LeftButton )
         setCursor( Qt::ArrowCursor );
 }
 
 void ToolBarPrivate::buildToolBar()
 {
     int buttonsNumber = buttons.count(),
         parentWidth = anchorWidget->width(),
         parentHeight = anchorWidget->height(),
         myCols = 1,
         myRows = 1;
 
     // 1. find out columns and rows we're going to use
     bool topLeft = anchorSide == PageViewToolBar::Left || anchorSide == PageViewToolBar::Top;
     bool vertical = anchorSide == PageViewToolBar::Left || anchorSide == PageViewToolBar::Right;
     if ( vertical )
     {
         myCols = 1 + (buttonsNumber * toolBarGridSize) /
                  (parentHeight - toolBarGridSize);
         myRows = (int)ceil( (float)buttonsNumber / (float)myCols );
     }
     else
     {
         myRows = 1 + (buttonsNumber * toolBarGridSize) /
                  (parentWidth - toolBarGridSize);
         myCols = (int)ceil( (float)buttonsNumber / (float)myRows );
     }
 
     // 2. compute widget size (from rows/cols)
     int myWidth = myCols * toolBarGridSize,
         myHeight = myRows * toolBarGridSize,
         xOffset = (toolBarGridSize - ToolBarButton::buttonSize) / 2,
         yOffset = (toolBarGridSize - ToolBarButton::buttonSize) / 2;
 
     if ( vertical )
     {
         myHeight += 16;
         myWidth += 4;
         yOffset += 12;
         if ( anchorSide == PageViewToolBar::Right )
             xOffset += 4;
     }
     else
     {
         myWidth += 16;
         myHeight += 4;
         xOffset += 12;
         if ( anchorSide == PageViewToolBar::Bottom )
             yOffset += 4;
     }
 
     bool prevUpdates = q->updatesEnabled();
     q->setUpdatesEnabled( false );
 
     // 3. resize pixmap, mask and widget
     QBitmap mask( myWidth + 1, myHeight + 1 );
     backgroundPixmap = QPixmap( myWidth + 1, myHeight + 1 );
     backgroundPixmap.fill(Qt::transparent);
     q->resize( myWidth + 1, myHeight + 1 );
 
     // 4. create and set transparency mask          // 4. draw background
     QPainter maskPainter( &mask);
     mask.fill( Qt::white );     
     maskPainter.setBrush( Qt::black );          
     if ( vertical )     
         maskPainter.drawRoundRect( topLeft ? -10 : 0, 0, myWidth + 11, myHeight, 2000 / (myWidth + 10), 2000 / myHeight );      
     else        
         maskPainter.drawRoundRect( 0, topLeft ? -10 : 0, myWidth, myHeight + 11, 2000 / myWidth, 2000 / (myHeight + 10) );      
     maskPainter.end();          
     q->setMask( mask );
 
     // 5. draw background
     QPainter bufferPainter( &backgroundPixmap );
     bufferPainter.translate( 0.5, 0.5 );
     QPalette pal = q->palette();
     // 5.1. draw horizontal/vertical gradient
     QLinearGradient grad;
     switch ( anchorSide )
     {
         case PageViewToolBar::Left:
             grad = QLinearGradient( 0, 1, myWidth + 1, 1 );
             break;
         case PageViewToolBar::Right:
             grad = QLinearGradient( myWidth + 1, 1, 0, 1 );
             break;
         case PageViewToolBar::Top:
             grad = QLinearGradient( 1, 0, 1, myHeight + 1 );
             break;
         case PageViewToolBar::Bottom:
             grad = QLinearGradient( 1, myHeight + 1, 0, 1 );
             break;
     }
     grad.setColorAt( 0, pal.color( QPalette::Active, QPalette::Button ) );
     grad.setColorAt( 1, pal.color( QPalette::Active, QPalette::Light ) );
     bufferPainter.setBrush( QBrush( grad ) );
     // 5.2. draw rounded border
     bufferPainter.setPen( pal.color( QPalette::Active, QPalette::Dark ).lighter( 140 ) );
     bufferPainter.setRenderHints( QPainter::Antialiasing );
     if ( vertical )
         bufferPainter.drawRoundRect( topLeft ? -10 : 0, 0, myWidth + 10, myHeight, 2000 / (myWidth + 10), 2000 / myHeight );
     else
         bufferPainter.drawRoundRect( 0, topLeft ? -10 : 0, myWidth, myHeight + 10, 2000 / myWidth, 2000 / (myHeight + 10) );
     // 5.3. draw handle
     bufferPainter.translate( -0.5, -0.5 );
     bufferPainter.setPen( pal.color( QPalette::Active, QPalette::Mid ) );
     if ( vertical )
     {
         int dx = anchorSide == PageViewToolBar::Left ? 2 : 4;
         bufferPainter.drawLine( dx, 6, dx + myWidth - 8, 6 );
         bufferPainter.drawLine( dx, 9, dx + myWidth - 8, 9 );
         bufferPainter.setPen( pal.color( QPalette::Active, QPalette::Light ) );
         bufferPainter.drawLine( dx + 1, 7, dx + myWidth - 7, 7 );
         bufferPainter.drawLine( dx + 1, 10, dx + myWidth - 7, 10 );
     }
     else
     {
         int dy = anchorSide == PageViewToolBar::Top ? 2 : 4;
         bufferPainter.drawLine( 6, dy, 6, dy + myHeight - 8 );
         bufferPainter.drawLine( 9, dy, 9, dy + myHeight - 8 );
         bufferPainter.setPen( pal.color( QPalette::Active, QPalette::Light ) );
         bufferPainter.drawLine( 7, dy + 1, 7, dy + myHeight - 7 );
         bufferPainter.drawLine( 10, dy + 1, 10, dy + myHeight - 7 );
     }
     bufferPainter.end();
 
     // 6. reposition buttons (in rows/col grid)
     int gridX = 0,
         gridY = 0;
     QLinkedList< ToolBarButton * >::const_iterator it = buttons.begin(), end = buttons.end();
     for ( ; it != end; ++it )
     {
         ToolBarButton * button = *it;
         button->move( gridX * toolBarGridSize + xOffset,
                       gridY * toolBarGridSize + yOffset );
         button->show();
         if ( ++gridX == myCols )
         {
             gridX = 0;
             gridY++;
         }
     }
 
     q->setUpdatesEnabled( prevUpdates );
 }
 
 void ToolBarPrivate::reposition()
 {
     // note: hiding widget here will gives better gfx, but ends drag operation
     // rebuild widget and move it to its final place
     buildToolBar();
     if ( !visible )
     {
         currentPosition = getOuterPoint();
         endPosition = getInnerPoint();
     }
     else
     {
         currentPosition = getInnerPoint();
         endPosition = getOuterPoint();
     }
     q->move( currentPosition );
 
     // repaint all buttons (to update background)
     QLinkedList< ToolBarButton * >::const_iterator it = buttons.begin(), end = buttons.end();
     for ( ; it != end; ++it )
         (*it)->update();
 }
 
 QPoint ToolBarPrivate::getInnerPoint() const
 {
     // returns the final position of the widget
     QPoint newPos;
     switch ( anchorSide )
     {
         case PageViewToolBar::Left:
             newPos = QPoint( 0, ( anchorWidget->height() - q->height() ) / 2 );
             break;
         case PageViewToolBar::Top:
             newPos = QPoint( ( anchorWidget->width() - q->width() ) / 2, 0 );
             break;
         case PageViewToolBar::Right:
             newPos = QPoint( anchorWidget->width() - q->width(), ( anchorWidget->height() - q->height() ) / 2 );
             break;
         case PageViewToolBar::Bottom:
             newPos = QPoint( ( anchorWidget->width() - q->width()) / 2, anchorWidget->height() - q->height() );
             break;
     }
     return newPos + anchorWidget->pos();
 }
 
 QPoint ToolBarPrivate::getOuterPoint() const
 {
     // returns the point from which the transition starts
     QPoint newPos;
     switch ( anchorSide )
     {
         case PageViewToolBar::Left:
             newPos = QPoint( -q->width(), ( anchorWidget->height() - q->height() ) / 2 );
             break;
         case PageViewToolBar::Top:
             newPos = QPoint( ( anchorWidget->width() - q->width() ) / 2, -q->height() );
             break;
         case PageViewToolBar::Right:
             newPos = QPoint( anchorWidget->width(), ( anchorWidget->height() - q->height() ) / 2 );
             break;
         case PageViewToolBar::Bottom:
             newPos = QPoint( ( anchorWidget->width() - q->width() ) / 2, anchorWidget->height() );
             break;
     }
     return newPos + anchorWidget->pos();
 }
 
 void PageViewToolBar::slotAnimate()
 {
     // move currentPosition towards endPosition
     int dX = d->endPosition.x() - d->currentPosition.x(),
         dY = d->endPosition.y() - d->currentPosition.y();
     dX = dX / 6 + qMax( -1, qMin( 1, dX) );
     dY = dY / 6 + qMax( -1, qMin( 1, dY) );
     d->currentPosition.setX( d->currentPosition.x() + dX );
     d->currentPosition.setY( d->currentPosition.y() + dY );
 
     // move the widget
     move( d->currentPosition );
 
     // handle arrival to the end
     if ( d->currentPosition == d->endPosition )
     {
         d->animTimer->stop();
         if ( d->hiding )
         {
             d->visible = false;
             deleteLater();
         }
         else
         {
             d->visible = true;
         }
     }
 }
 
 void PageViewToolBar::slotButtonClicked()
 {
     ToolBarButton * button = qobject_cast<ToolBarButton *>( sender() );
     d->selectButton( button );
 }
 
 void ToolBarPrivate::selectButton( ToolBarButton * button )
 {
     if ( button )
     {
         // deselect other buttons
         QLinkedList< ToolBarButton * >::const_iterator it = buttons.begin(), end = buttons.end();
         for ( ; it != end; ++it )
             if ( *it != button )
                 (*it)->setChecked( false );
         // emit signal (-1 if button has been unselected)
         emit q->toolSelected( button->isChecked() ? button->buttonID() : -1 );
     }
 }
 
 void PageViewToolBar::setToolsEnabled( bool on )
 {
     QLinkedList< ToolBarButton * >::const_iterator it = d->buttons.begin(), end = d->buttons.end();
     for ( ; it != end; ++it )
         (*it)->setEnabled( on );
 }
 
 void PageViewToolBar::setTextToolsEnabled( bool on )
 {
     QLinkedList< ToolBarButton * >::const_iterator it = d->buttons.begin(), end = d->buttons.end();
     for ( ; it != end; ++it )
         if ( (*it)->isText() )
             (*it)->setEnabled( on );
 }
 
 #include "moc_pageviewutils.cpp"
diff --git a/ui/pageviewutils.h b/ui/pageviewutils.h
index 19f24f9b4..ca8bd78a4 100644
--- a/ui/pageviewutils.h
+++ b/ui/pageviewutils.h
@@ -1,221 +1,220 @@
 /***************************************************************************
  *   Copyright (C) 2004-2005 by Enrico Ros <eros.kde@email.it>             *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #ifndef _PAGEVIEW_UTILS_H_
 #define _PAGEVIEW_UTILS_H_
 
 #include <qwidget.h>
 #include <qpixmap.h>
 #include <qrect.h>
 #include <qhash.h>
 #include <qtoolbutton.h>
 
 
 #include "core/area.h"
 
 class QAction;
 class QLabel;
 class QTimer;
 class FormWidgetIface;
 class PageView;
 class VideoWidget;
 
 namespace Okular {
 class Movie;
 class Page;
 }
 
 /**
  * @short PageViewItem represents graphically a page into the PageView.
  *
  * It has methods for settings Item's geometry and other visual properties such
  * as the individual zoom factor.
  */
 class PageViewItem
 {
     public:
-        PageViewItem( const Okular::Page * page, qreal dpr );
+        PageViewItem( const Okular::Page * page );
         ~PageViewItem();
 
         const Okular::Page * page() const;
         int pageNumber() const;
         double zoomFactor() const;
         bool isVisible() const;
         QHash<int, FormWidgetIface*>& formWidgets();
         QHash< Okular::Movie *, VideoWidget * >& videoWidgets();
 
         /* The page is cropped as follows: */
         const Okular::NormalizedRect & crop() const;
 
         /* Real geometry into which the cropped page is rendered: */
         const QRect& croppedGeometry() const;
         int croppedWidth() const;
         int croppedHeight() const;
 
         /* "Uncropped" geometry:
          * If the whole page was rendered into the uncropped geometry then the
          * cropped page would be rendered into the real geometry.
          * (Hence, uncropped always contains cropped, and they are equal only if
          * the page is uncropped.) This is just for convenience in calculations.
          */
         const QRect& uncroppedGeometry() const;
         int uncroppedWidth() const;
         int uncroppedHeight() const;
 
         /* Convert absolute geometry coordinates to normalized [0,1] page coordinates: */
         double absToPageX(double absX) const;
         double absToPageY(double absY) const;
 
         void setWHZC( int w, int h, double zoom, const Okular::NormalizedRect & c );
         void moveTo( int x, int y );
         void setVisible( bool visible );
         void invalidate();
         bool setFormWidgetsVisible( bool visible );
         void reloadFormWidgetsState();
 
     private:
         const Okular::Page * m_page;
-        qreal m_dpr;
         double m_zoomFactor;
         bool m_visible;
         bool m_formsVisible;
         QRect m_croppedGeometry;
         QRect m_uncroppedGeometry;
         Okular::NormalizedRect m_crop;
         QHash<int, FormWidgetIface*> m_formWidgets;
         QHash< Okular::Movie *, VideoWidget * > m_videoWidgets;
 };
 
 
 /**
  * @short A widget that displays messages in the top-left corner.
  *
  * This is a widget with thin border and rounded corners that displays a given
  * text along as an icon. It's meant to be used for displaying messages to the
  * user by placing this above other widgets.
  */
 class PageViewMessage : public QWidget
 {
     Q_OBJECT
 
     public:
         PageViewMessage( QWidget * parent );
 
         enum Icon { None, Info, Warning, Error, Find, Annotation };
         void display( const QString & message, const QString & details = QString(), Icon icon = Info, int durationMs = 4000 );
 
     protected:
         bool eventFilter(QObject * obj, QEvent * event ) override;
         void paintEvent( QPaintEvent * e ) override;
         void mousePressEvent( QMouseEvent * e ) override;
 
     private:
         QRect computeTextRect( const QString & message, int extra_width ) const;
         void computeSizeAndResize();
         QString m_message;
         QString m_details;
         QPixmap m_symbol;
         QTimer * m_timer;
         int m_lineSpacing;
 };
 
 struct AnnotationToolItem
 {
     AnnotationToolItem()
         : id( -1 ), isText( false )
     {
     }
 
     int id;
     QString text;
     QPixmap pixmap;
     QString shortcut;
     bool isText;
 };
 
 class ToolBarButton : public QToolButton
 {
     Q_OBJECT
     public:
         static const int iconSize = 32;
         static const int buttonSize = 40;
 
         ToolBarButton( QWidget * parent, const AnnotationToolItem &item );
         int buttonID() const { return m_id; }
         bool isText() const { return m_isText; }
 
     Q_SIGNALS:
         void buttonDoubleClicked( int buttonID );
 
     protected:
         void mouseDoubleClickEvent( QMouseEvent * event ) override;
 
     private:
         int m_id;
         bool m_isText;
 };
 
 /**
  * @short A widget containing exclusive buttons, that slides in from a side.
  *
  * This is a shaped widget that slides in from a side of the 'anchor widget'
  * it's attached to. It can be dragged and docked on {left,top,right,bottom}
  * sides and contains toggable exclusive buttons.
  * When a 'tool' of this 'toolBar' is selected, a signal is emitted.
  */
 class PageViewToolBar : public QWidget
 {
     Q_OBJECT
     public:
         PageViewToolBar( PageView * parent, QWidget * anchorWidget );
         ~PageViewToolBar();
 
         // animated widget controls
         enum Side { Left = 0, Top = 1, Right = 2, Bottom = 3 };
 
         void setItems( const QLinkedList<AnnotationToolItem> &items );
         void setSide( Side side );
 
         void showAndAnimate();
         void hideAndDestroy();
 
         void selectButton( int id );
 
         void setToolsEnabled( bool on );
         void setTextToolsEnabled( bool on );
 
         // query properties
 
     Q_SIGNALS:
         // the tool 'toolID' has been selected
         void toolSelected( int toolID );
         // orientation has been changed
         void orientationChanged( int side );
         // a tool button of this toolbar has been double clicked
         void buttonDoubleClicked( int buttonID );
 
     protected:
         // handle widget events { anchor_resize, paint, animation, drag }
         bool eventFilter( QObject * o, QEvent * e ) override;
         void paintEvent( QPaintEvent * ) override;
         void mousePressEvent( QMouseEvent * e ) override;
         void mouseMoveEvent( QMouseEvent * e ) override;
         void mouseReleaseEvent( QMouseEvent * e ) override;
 
     private:
         // private variables
         friend class ToolBarPrivate;
         class ToolBarPrivate * d;
 
     private Q_SLOTS:
         void slotAnimate();
         void slotButtonClicked();
 };
 
 #endif
diff --git a/ui/presentationwidget.cpp b/ui/presentationwidget.cpp
index acb2a1f17..7e28b1166 100644
--- a/ui/presentationwidget.cpp
+++ b/ui/presentationwidget.cpp
@@ -1,2473 +1,2473 @@
 /***************************************************************************
  *   Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>                  *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "presentationwidget.h"
 
 // qt/kde includes
 #include <QtCore/qloggingcategory.h>
 #include <QtDBus/QDBusConnection>
 #include <QtDBus/QDBusMessage>
 #include <QtDBus/QDBusReply>
 
 #include <qevent.h>
 #include <qfontmetrics.h>
 #include <QIcon>
 #include <qtimer.h>
 #include <qimage.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qpainter.h>
 #include <qstyle.h>
 #include <qstyleoption.h>
 #include <qtooltip.h>
 #include <qvalidator.h>
 #include <qapplication.h>
 #include <qdesktopwidget.h>
 #include <QGestureEvent>
 #include <kcursor.h>
 #include <krandom.h>
 #include <qtoolbar.h>
 #include <qaction.h>
 #include <kactioncollection.h>
 #include <klineedit.h>
 #include <KLocalizedString>
 #include <kiconloader.h>
 #include <kmessagebox.h>
 #include <kselectaction.h>
 #include <QDialog>
 
 #ifdef Q_OS_LINUX
 #include <QDBusUnixFileDescriptor>
 #include <unistd.h> // For ::close() for sleep inhibition
 #endif
 
 // system includes
 #include <stdlib.h>
 #include <math.h>
 
 // local includes
 #include "annotationtools.h"
 #include "debug_ui.h"
 #include "drawingtoolactions.h"
 #include "guiutils.h"
 #include "pagepainter.h"
 #include "presentationsearchbar.h"
 #include "priorities.h"
 #include "videowidget.h"
 #include "core/action.h"
 #include "core/annotations.h"
 #include "core/audioplayer.h"
 #include "core/document.h"
 #include "core/generator.h"
 #include "core/movie.h"
 #include "core/page.h"
 #include "settings.h"
 #include "settings_core.h"
 
 // comment this to disable the top-right progress indicator
 #define ENABLE_PROGRESS_OVERLAY
 
 
 // a frame contains a pointer to the page object, its geometry and the
 // transition effect to the next frame
 struct PresentationFrame
 {
     ~PresentationFrame()
     {
         qDeleteAll( videoWidgets );
     }
 
     void recalcGeometry( int width, int height, float screenRatio, qreal dpr )
     {
         // calculate frame geometry keeping constant aspect ratio
         float pageRatio = page->ratio();
         qreal pageWidth = width,
               pageHeight = height;
         if ( pageRatio > screenRatio )
             pageWidth = (int)( (float)pageHeight / pageRatio );
         else
             pageHeight = (int)( (float)pageWidth * pageRatio );
         geometry.setRect( (( width - pageWidth ) / 2) /** dpr*/,
                           (( height - pageHeight ) / 2) /** dpr*/,
                           pageWidth /** dpr*/, pageHeight /** dpr */);
         
         qDebug() << "PW recalcGeometry geometry" << geometry;
         
         Q_FOREACH ( VideoWidget *vw, videoWidgets )
         {
             const Okular::NormalizedRect r = vw->normGeometry();
             QRect vwgeom = r.geometry( geometry.width(), geometry.height() );
             vw->resize( vwgeom.size() );
             vw->move( geometry.topLeft() + vwgeom.topLeft() );
         }
     }
 
     const Okular::Page * page;
     QRect geometry;
     QHash< Okular::Movie *, VideoWidget * > videoWidgets;
     QLinkedList< SmoothPath > drawings;
 };
 
 
 // a custom QToolBar that basically does not propagate the event if the widget
 // background is not automatically filled
 class PresentationToolBar : public QToolBar
 {
     Q_OBJECT
 
     public:
         PresentationToolBar( QWidget * parent = Q_NULLPTR )
             : QToolBar( parent )
         {}
 
     protected:
         void mousePressEvent( QMouseEvent * e ) override
         {
             QToolBar::mousePressEvent( e );
             e->accept();
         }
 
         void mouseReleaseEvent( QMouseEvent * e ) override
         {
             QToolBar::mouseReleaseEvent( e );
             e->accept();
         }
 };
 
 
 PresentationWidget::PresentationWidget( QWidget * parent, Okular::Document * doc, DrawingToolActions * drawingToolActions, KActionCollection * collection )
     : QWidget( 0 /* must be null, to have an independent widget */, Qt::FramelessWindowHint ),
     m_pressedLink( 0 ), m_handCursor( false ), m_drawingEngine( 0 ),
     m_screenInhibitCookie(0), m_sleepInhibitCookie(0),
     m_parentWidget( parent ),
     m_document( doc ), m_frameIndex( -1 ), m_topBar( 0 ), m_pagesEdit( 0 ), m_searchBar( 0 ),
     m_ac( collection ), m_screenSelect( 0 ), m_isSetup( false ), m_blockNotifications( false ), m_inBlackScreenMode( false ),
     m_showSummaryView( Okular::Settings::slidesShowSummary() ),
     m_advanceSlides( Okular::SettingsCore::slidesAdvance() ),
     m_goToNextPageOnRelease( false )
 {
     Q_UNUSED( parent )
     setAttribute( Qt::WA_DeleteOnClose );
     setAttribute( Qt::WA_OpaquePaintEvent );
     setObjectName( QStringLiteral( "presentationWidget" ) );
     QString caption = doc->metaData( QStringLiteral("DocumentTitle") ).toString();
     if ( caption.trimmed().isEmpty() )
         caption = doc->currentDocument().fileName();
     caption = i18nc( "[document title/filename] – Presentation", "%1 – Presentation", caption );
     setWindowTitle( caption );
 
     m_width = -1;
     m_screen = -2;
 
     // create top toolbar
     m_topBar = new PresentationToolBar( this );
     m_topBar->setObjectName( QStringLiteral( "presentationBar" ) );
     m_topBar->setMovable( false );
     m_topBar->layout()->setMargin(0);
     m_topBar->addAction( QIcon::fromTheme( layoutDirection() == Qt::RightToLeft ? QStringLiteral("go-next") : QStringLiteral("go-previous") ), i18n( "Previous Page" ), this, SLOT(slotPrevPage()) );
     m_pagesEdit = new KLineEdit( m_topBar );
     QSizePolicy sp = m_pagesEdit->sizePolicy();
     sp.setHorizontalPolicy( QSizePolicy::Minimum );
     m_pagesEdit->setSizePolicy( sp );
     QFontMetrics fm( m_pagesEdit->font() );
     QStyleOptionFrame option;
     option.initFrom( m_pagesEdit );
     m_pagesEdit->setMaximumWidth( fm.width( QString::number( m_document->pages() ) ) + 2 * style()->pixelMetric( QStyle::PM_DefaultFrameWidth, &option, m_pagesEdit ) + 4 ); // the 4 comes from 2*horizontalMargin, horizontalMargin being a define in qlineedit.cpp
     QIntValidator *validator = new QIntValidator( 1, m_document->pages(), m_pagesEdit );
     m_pagesEdit->setValidator( validator );
     m_topBar->addWidget( m_pagesEdit );
     QLabel *pagesLabel = new QLabel( m_topBar );
     pagesLabel->setText( QLatin1String( " / " ) + QString::number( m_document->pages() ) + QLatin1String( " " ) );
     m_topBar->addWidget( pagesLabel );
     connect(m_pagesEdit, &QLineEdit::returnPressed, this, &PresentationWidget::slotPageChanged);
     m_topBar->addAction( QIcon::fromTheme( layoutDirection() == Qt::RightToLeft ? QStringLiteral("go-previous") : QStringLiteral("go-next") ), i18n( "Next Page" ), this, SLOT(slotNextPage()) );
     m_topBar->addSeparator();
     QAction *playPauseAct = collection->action( QStringLiteral("presentation_play_pause") );
     playPauseAct->setEnabled( true );
     connect(playPauseAct, &QAction::triggered, this, &PresentationWidget::slotTogglePlayPause);
     m_topBar->addAction( playPauseAct );
     setPlayPauseIcon();
     addAction( playPauseAct );
     m_topBar->addSeparator();
     QAction *eraseDrawingAct = collection->action( QStringLiteral("presentation_erase_drawings") );
     eraseDrawingAct->setEnabled( true );
     connect(eraseDrawingAct, &QAction::triggered, this, &PresentationWidget::clearDrawings);
     m_topBar->addAction( eraseDrawingAct );
     addAction( eraseDrawingAct );
 
     foreach(QAction *action, drawingToolActions->actions())
     {
         action->setEnabled( true );
         m_topBar->addAction( action );
         addAction( action );
     }
     connect( drawingToolActions, &DrawingToolActions::changeEngine, this, &PresentationWidget::slotChangeDrawingToolEngine );
     connect( drawingToolActions, &DrawingToolActions::actionsRecreated, this, &PresentationWidget::slotAddDrawingToolActions );
 
     QDesktopWidget *desktop = QApplication::desktop();
     if ( desktop->numScreens() > 1 )
     {
         m_topBar->addSeparator();
         m_screenSelect = new KSelectAction( QIcon::fromTheme( QStringLiteral("video-display") ), i18n( "Switch Screen" ), m_topBar );
         m_screenSelect->setToolBarMode( KSelectAction::MenuMode );
         m_screenSelect->setToolButtonPopupMode( QToolButton::InstantPopup );
         m_topBar->addAction( m_screenSelect );
         const int screenCount = desktop->numScreens();
         for ( int i = 0; i < screenCount; ++i )
         {
             QAction *act = m_screenSelect->addAction( i18nc( "%1 is the screen number (0, 1, ...)", "Screen %1", i ) );
             act->setData( qVariantFromValue( i ) );
         }
     }
     QWidget *spacer = new QWidget( m_topBar );
     spacer->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::MinimumExpanding );
     m_topBar->addWidget( spacer );
     m_topBar->addAction( QIcon::fromTheme( QStringLiteral("application-exit") ), i18n( "Exit Presentation Mode" ), this, SLOT(close()) );
     m_topBar->setAutoFillBackground( true );
     showTopBar( false );
     // change topbar background color
     QPalette p = m_topBar->palette();
     p.setColor( QPalette::Active, QPalette::Button, Qt::gray );
     p.setColor( QPalette::Active, QPalette::Background, Qt::darkGray );
     m_topBar->setPalette( p );
 
     // Grab swipe gestures to change pages
     grabGesture(Qt::SwipeGesture);
 
     // misc stuff
     setMouseTracking( true );
     setContextMenuPolicy( Qt::PreventContextMenu );
     m_transitionTimer = new QTimer( this );
     m_transitionTimer->setSingleShot( true );
     connect(m_transitionTimer, &QTimer::timeout, this, &PresentationWidget::slotTransitionStep);
     m_overlayHideTimer = new QTimer( this );
     m_overlayHideTimer->setSingleShot( true );
     connect(m_overlayHideTimer, &QTimer::timeout, this, &PresentationWidget::slotHideOverlay);
     m_nextPageTimer = new QTimer( this );
     m_nextPageTimer->setSingleShot( true );
     connect(m_nextPageTimer, &QTimer::timeout, this, &PresentationWidget::slotNextPage);
 
     connect(m_document, &Okular::Document::processMovieAction, this, &PresentationWidget::slotProcessMovieAction);
     connect(m_document, &Okular::Document::processRenditionAction, this, &PresentationWidget::slotProcessRenditionAction);
 
     // handle cursor appearance as specified in configuration
     if ( Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay )
     {
         KCursor::setAutoHideCursor( this, true );
         KCursor::setHideCursorDelay( 3000 );
     }
     else if ( Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden )
     {
         setCursor( QCursor( Qt::BlankCursor ) );
     }
 
     setupActions();
 
     // inhibit power management
     inhibitPowerManagement();
 
     show();
 
     QTimer::singleShot( 0, this, &PresentationWidget::slotDelayedEvents );
 
     // setFocus() so KCursor::setAutoHideCursor() goes into effect if it's enabled
     setFocus( Qt::OtherFocusReason );
 }
 
 PresentationWidget::~PresentationWidget()
 {
     // allow power management saver again
     allowPowerManagement();
 
     // stop the audio playbacks
     Okular::AudioPlayer::instance()->stopPlaybacks();
 
     // remove our highlights
     if ( m_searchBar )
     {
         m_document->resetSearch( PRESENTATION_SEARCH_ID );
     }
 
     // remove this widget from document observer
     m_document->removeObserver( this );
 
     foreach( QAction *action, m_topBar->actions() )
     {
         action->setChecked( false );
         action->setEnabled( false );
     }
 
     delete m_drawingEngine;
 
     // delete frames
     QVector< PresentationFrame * >::iterator fIt = m_frames.begin(), fEnd = m_frames.end();
     for ( ; fIt != fEnd; ++fIt )
         delete *fIt;
 }
 
 
 void PresentationWidget::notifySetup( const QVector< Okular::Page * > & pageSet, int setupFlags )
 {
     // same document, nothing to change - here we assume the document sets up
     // us with the whole document set as first notifySetup()
     if ( !( setupFlags & Okular::DocumentObserver::DocumentChanged ) )
         return;
 
     // delete previous frames (if any (shouldn't be))
     QVector< PresentationFrame * >::iterator fIt = m_frames.begin(), fEnd = m_frames.end();
     for ( ; fIt != fEnd; ++fIt )
         delete *fIt;
     if ( !m_frames.isEmpty() )
         qCWarning(OkularUiDebug) << "Frames setup changed while a Presentation is in progress.";
     m_frames.clear();
 
     // create the new frames
     QVector< Okular::Page * >::const_iterator setIt = pageSet.begin(), setEnd = pageSet.end();
     float screenRatio = (float)m_height / (float)m_width;
     for ( ; setIt != setEnd; ++setIt )
     {
         PresentationFrame * frame = new PresentationFrame();
         frame->page = *setIt;
         const QLinkedList< Okular::Annotation * > annotations = (*setIt)->annotations();
         QLinkedList< Okular::Annotation * >::const_iterator aIt = annotations.begin(), aEnd = annotations.end();
         for ( ; aIt != aEnd; ++aIt )
         {
             Okular::Annotation * a = *aIt;
             if ( a->subType() == Okular::Annotation::AMovie )
             {
                 Okular::MovieAnnotation * movieAnn = static_cast< Okular::MovieAnnotation * >( a );
                 VideoWidget * vw = new VideoWidget( movieAnn, movieAnn->movie(), m_document, this );
                 frame->videoWidgets.insert( movieAnn->movie(), vw );
                 vw->pageInitialized();
             }
             else if ( a->subType() == Okular::Annotation::ARichMedia )
             {
                 Okular::RichMediaAnnotation * richMediaAnn = static_cast< Okular::RichMediaAnnotation * >( a );
                 if ( richMediaAnn->movie() ) {
                     VideoWidget * vw = new VideoWidget( richMediaAnn, richMediaAnn->movie(), m_document, this );
                     frame->videoWidgets.insert( richMediaAnn->movie(), vw );
                     vw->pageInitialized();
                 }
             }
             else if ( a->subType() == Okular::Annotation::AScreen )
             {
                 const Okular::ScreenAnnotation * screenAnn = static_cast< Okular::ScreenAnnotation * >( a );
                 Okular::Movie *movie = GuiUtils::renditionMovieFromScreenAnnotation( screenAnn );
                 if ( movie )
                 {
                     VideoWidget * vw = new VideoWidget( screenAnn, movie, m_document, this );
                     frame->videoWidgets.insert( movie, vw );
                     vw->pageInitialized();
                 }
             }
         }
         frame->recalcGeometry( m_width, m_height, screenRatio, qApp->devicePixelRatio() );
         // add the frame to the vector
         m_frames.push_back( frame );
     }
 
     // get metadata from the document
     m_metaStrings.clear();
     const Okular::DocumentInfo info = m_document->documentInfo( QSet<Okular::DocumentInfo::Key>() << Okular::DocumentInfo::Title << Okular::DocumentInfo::Author );
     if ( !info.get( Okular::DocumentInfo::Title ).isNull() )
         m_metaStrings += i18n( "Title: %1", info.get( Okular::DocumentInfo::Title ) );
     if ( !info.get( Okular::DocumentInfo::Author ).isNull() )
         m_metaStrings += i18n( "Author: %1", info.get( Okular::DocumentInfo::Author ) );
     m_metaStrings += i18n( "Pages: %1", m_document->pages() );
     m_metaStrings += i18n( "Click to begin" );
 
     m_isSetup = true;
 }
 
 void PresentationWidget::notifyViewportChanged( bool /*smoothMove*/ )
 {
     // display the current page
     changePage( m_document->viewport().pageNumber );
 
     // auto advance to the next page if set
     startAutoChangeTimer();
 }
 
 void PresentationWidget::notifyPageChanged( int pageNumber, int changedFlags )
 {
     // if we are blocking the notifications, do nothing
     if ( m_blockNotifications )
         return;
 
     // check if it's the last requested pixmap. if so update the widget.
     if ( (changedFlags & ( DocumentObserver::Pixmap | DocumentObserver::Annotations | DocumentObserver::Highlights ) ) && pageNumber == m_frameIndex )
         generatePage( changedFlags & ( DocumentObserver::Annotations | DocumentObserver::Highlights ) );
 }
 
 void PresentationWidget::notifyCurrentPageChanged( int previousPage, int currentPage )
 {
     if ( previousPage != -1 )
     {
         // stop video playback
         Q_FOREACH ( VideoWidget *vw, m_frames[ previousPage ]->videoWidgets )
         {
             vw->stop();
             vw->pageLeft();
         }
 
         // stop audio playback, if any
         Okular::AudioPlayer::instance()->stopPlaybacks();
 
         // perform the page closing action, if any
         if ( m_document->page( previousPage )->pageAction( Okular::Page::Closing ) )
             m_document->processAction( m_document->page( previousPage )->pageAction( Okular::Page::Closing ) );
 
         // perform the additional actions of the page's annotations, if any
         Q_FOREACH ( const Okular::Annotation *annotation, m_document->page( previousPage )->annotations() )
         {
             Okular::Action *action = 0;
 
             if ( annotation->subType() == Okular::Annotation::AScreen )
                 action = static_cast<const Okular::ScreenAnnotation*>( annotation )->additionalAction( Okular::Annotation::PageClosing );
             else if ( annotation->subType() == Okular::Annotation::AWidget )
                 action = static_cast<const Okular::WidgetAnnotation*>( annotation )->additionalAction( Okular::Annotation::PageClosing );
 
             if ( action )
                 m_document->processAction( action );
         }
     }
 
     if ( currentPage != -1 )
     {
         m_frameIndex = currentPage;
 
         // check if pixmap exists or else request it
         PresentationFrame * frame = m_frames[ m_frameIndex ];
         int pixW = frame->geometry.width();
         int pixH = frame->geometry.height();
 
         bool signalsBlocked = m_pagesEdit->signalsBlocked();
         m_pagesEdit->blockSignals( true );
         m_pagesEdit->setText( QString::number( m_frameIndex + 1 ) );
         m_pagesEdit->blockSignals( signalsBlocked );
 
         // if pixmap not inside the Okular::Page we request it and wait for
         // notifyPixmapChanged call or else we can proceed to pixmap generation
         if ( !frame->page->hasPixmap( this, pixW, pixH ) )
         {
             requestPixmaps();
         }
         else
         {
             // make the background pixmap
             generatePage();
         }
 
         // perform the page opening action, if any
         if ( m_document->page( m_frameIndex )->pageAction( Okular::Page::Opening ) )
             m_document->processAction( m_document->page( m_frameIndex )->pageAction( Okular::Page::Opening ) );
 
         // perform the additional actions of the page's annotations, if any
         Q_FOREACH ( const Okular::Annotation *annotation, m_document->page( m_frameIndex )->annotations() )
         {
             Okular::Action *action = 0;
 
             if ( annotation->subType() == Okular::Annotation::AScreen )
                 action = static_cast<const Okular::ScreenAnnotation*>( annotation )->additionalAction( Okular::Annotation::PageOpening );
             else if ( annotation->subType() == Okular::Annotation::AWidget )
                 action = static_cast<const Okular::WidgetAnnotation*>( annotation )->additionalAction( Okular::Annotation::PageOpening );
 
             if ( action )
                 m_document->processAction( action );
         }
 
         // start autoplay video playback
         Q_FOREACH ( VideoWidget *vw, m_frames[ m_frameIndex ]->videoWidgets )
             vw->pageEntered();
     }
 }
 
 bool PresentationWidget::canUnloadPixmap( int pageNumber ) const
 {
     if ( Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Low ||
          Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Normal )
     {
         // can unload all pixmaps except for the currently visible one
         return pageNumber != m_frameIndex;
     }
     else
     {
         // can unload all pixmaps except for the currently visible one, previous and next
         return qAbs(pageNumber - m_frameIndex) <= 1;
     }
 }
 
 void PresentationWidget::setupActions()
 {
     addAction( m_ac->action( QStringLiteral("first_page") ) );
     addAction( m_ac->action( QStringLiteral("last_page") ) );
     addAction( m_ac->action( QString::fromLocal8Bit(KStandardAction::name( KStandardAction::Prior ) ) ) );
     addAction( m_ac->action( QString::fromLocal8Bit(KStandardAction::name( KStandardAction::Next ) ) ) );
     addAction( m_ac->action( QString::fromLocal8Bit(KStandardAction::name( KStandardAction::DocumentBack ) ) ) );
     addAction( m_ac->action( QString::fromLocal8Bit(KStandardAction::name( KStandardAction::DocumentForward ) ) ) );
 
     QAction *action = m_ac->action( QStringLiteral("switch_blackscreen_mode") );
     connect(action, &QAction::toggled, this, &PresentationWidget::toggleBlackScreenMode);
     action->setEnabled( true );
     addAction( action );
 }
 
 void PresentationWidget::setPlayPauseIcon()
 {
     QAction *playPauseAction = m_ac->action( QStringLiteral("presentation_play_pause") );
     if ( m_advanceSlides )
     {
        playPauseAction->setIcon( QIcon::fromTheme( QStringLiteral("media-playback-pause") ) );
        playPauseAction->setToolTip( i18nc( "For Presentation", "Pause" ) );
     }
     else
     {
        playPauseAction->setIcon( QIcon::fromTheme( QStringLiteral("media-playback-start") ) );
        playPauseAction->setToolTip( i18nc( "For Presentation", "Play" ) );
     }
 }
 
 // <widget events>
 bool PresentationWidget::event( QEvent * e )
 {
     if ( e->type() == QEvent::Gesture )
         return gestureEvent(static_cast<QGestureEvent*>(e));
 
     if ( e->type() == QEvent::ToolTip )
     {
         QHelpEvent * he = (QHelpEvent*)e;
 
         QRect r;
         const Okular::Action * link = getLink( he->x(), he->y(), &r );
 
         if ( link )
         {
             QString tip = link->actionTip();
             if ( !tip.isEmpty() )
                 QToolTip::showText( he->globalPos(), tip, this, r );
         }
         e->accept();
         return true;
     }
     else
         // do not stop the event
         return QWidget::event( e );
 }
 
 bool PresentationWidget::gestureEvent( QGestureEvent * event )
 {
     // Swiping left or right on a touch screen will go to the previous or next slide, respectively.
     // The precise gesture is the standard Qt swipe: with three(!) fingers.
     if (QGesture *swipe = event->gesture(Qt::SwipeGesture))
     {
         QSwipeGesture * swipeEvent = static_cast<QSwipeGesture *>(swipe);
 
         if (swipeEvent->state() == Qt::GestureFinished)
         {
             if (swipeEvent->horizontalDirection() == QSwipeGesture::Left)
             {
                 slotPrevPage();
                 event->accept();
                 return true;
             }
             if (swipeEvent->horizontalDirection() == QSwipeGesture::Right)
             {
                 slotNextPage();
                 event->accept();
                 return true;
             }
         }
     }
 
     return false;
 }
 void PresentationWidget::keyPressEvent( QKeyEvent * e )
 {
     if ( !m_isSetup )
         return;
 
     switch ( e->key() )
     {
         case Qt::Key_Left:
         case Qt::Key_Backspace:
         case Qt::Key_PageUp:
         case Qt::Key_Up:
             slotPrevPage();
             break;
         case Qt::Key_Right:
         case Qt::Key_Space:
         case Qt::Key_PageDown:
         case Qt::Key_Down:
             slotNextPage();
             break;
         case Qt::Key_Home:
             slotFirstPage();
             break;
         case Qt::Key_End:
             slotLastPage();
             break;
         case Qt::Key_Escape:
             if ( !m_topBar->isHidden() )
                 showTopBar( false );
             else
                 close();
             break;
     }
 }
 
 void PresentationWidget::wheelEvent( QWheelEvent * e )
 {
     if ( !m_isSetup )
         return;
 
     // performance note: don't remove the clipping
     int div = e->delta() / 120;
     if ( div > 0 )
     {
         if ( div > 3 )
             div = 3;
         while ( div-- )
             slotPrevPage();
     }
     else if ( div < 0 )
     {
         if ( div < -3 )
             div = -3;
         while ( div++ )
             slotNextPage();
     }
 }
 
 void PresentationWidget::mousePressEvent( QMouseEvent * e )
 {
     if ( !m_isSetup )
         return;
 
     if ( m_drawingEngine )
     {
         QRect r = routeMouseDrawingEvent( e );
         if ( r.isValid() )
         {
             m_drawingRect |= r.translated( m_frames[ m_frameIndex ]->geometry.topLeft() );
             update( m_drawingRect );
         }
         return;
     }
 
     // pressing left button
     if ( e->button() == Qt::LeftButton )
     {
         // if pressing on a link, skip other checks
         if ( ( m_pressedLink = getLink( e->x(), e->y() ) ) )
             return;
 
         const Okular::Annotation *annotation = getAnnotation( e->x(), e->y() );
         if ( annotation )
         {
             if ( annotation->subType() == Okular::Annotation::AMovie )
             {
                 const Okular::MovieAnnotation *movieAnnotation = static_cast<const Okular::MovieAnnotation*>( annotation );
 
                 VideoWidget *vw = m_frames[ m_frameIndex ]->videoWidgets.value( movieAnnotation->movie() );
                 vw->show();
                 vw->play();
                 return;
             }
             else if ( annotation->subType() == Okular::Annotation::ARichMedia )
             {
                 const Okular::RichMediaAnnotation *richMediaAnnotation = static_cast<const Okular::RichMediaAnnotation*>( annotation );
 
                 VideoWidget *vw = m_frames[ m_frameIndex ]->videoWidgets.value( richMediaAnnotation->movie() );
                 vw->show();
                 vw->play();
                 return;
             }
             else if ( annotation->subType() == Okular::Annotation::AScreen )
             {
                 m_document->processAction( static_cast<const Okular::ScreenAnnotation*>( annotation )->action() );
                 return;
             }
         }
 
         // handle clicking on top-right overlay
         if ( !( Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden ) &&
              m_overlayGeometry.contains( e->pos() ) )
         {
             overlayClick( e->pos() );
             return;
         }
 
         m_goToNextPageOnRelease = true;
     }
     // pressing the "move forward" mouse button: unlike the left button this
     // always means "show next page", so we unconditionally delegate to that
     // action on mouse button press
     else if ( e->button() == Qt::ForwardButton ) {
         slotNextPage();
     }
     // pressing right or backward button
     else if ( e->button() == Qt::RightButton || e->button() == Qt::BackButton )
         slotPrevPage();
 }
 
 void PresentationWidget::mouseReleaseEvent( QMouseEvent * e )
 {
     if ( m_drawingEngine )
     {
         routeMouseDrawingEvent( e );
         return;
     }
 
     // if releasing on the same link we pressed over, execute it
     if ( m_pressedLink && e->button() == Qt::LeftButton )
     {
         const Okular::Action * link = getLink( e->x(), e->y() );
         if ( link == m_pressedLink )
             m_document->processAction( link );
         m_pressedLink = 0;
     }
 
     if ( m_goToNextPageOnRelease ) {
         slotNextPage();
         m_goToNextPageOnRelease = false;
     }
 }
 
 void PresentationWidget::mouseMoveEvent( QMouseEvent * e )
 {
     // safety check
     if ( !m_isSetup )
         return;
 
     // update cursor and tooltip if hovering a link
     if ( !m_drawingEngine && Okular::Settings::slidesCursor() != Okular::Settings::EnumSlidesCursor::Hidden )
         testCursorOnLink( e->x(), e->y() );
 
     if ( !m_topBar->isHidden() )
     {
         // hide a shown bar when exiting the area
         if ( e->y() > ( m_topBar->height() + 1 ) )
         {
             showTopBar( false );
             setFocus( Qt::OtherFocusReason );
         }
     }
     else
     {
         if ( m_drawingEngine && e->buttons() != Qt::NoButton )
         {
             QRect r = routeMouseDrawingEvent( e );
             if ( r.isValid() )
             {
                 m_drawingRect |= r.translated( m_frames[ m_frameIndex ]->geometry.topLeft() );
                 update( m_drawingRect );
             }
         }
         else
         {
             // show the bar if reaching top 2 pixels
             if ( e->y() <= 1 )
                 showTopBar( true );
             // handle "dragging the wheel" if clicking on its geometry
             else if ( ( QApplication::mouseButtons() & Qt::LeftButton ) && m_overlayGeometry.contains( e->pos() ) )
                 overlayClick( e->pos() );
         }
     }
 }
 
 void PresentationWidget::paintEvent( QPaintEvent * pe )
 {
     qreal dpr = devicePixelRatioF();
     
     //QPainter painter( this );
     //painter.fillRect( pe->rect(), Qt::green );
     
     if ( m_inBlackScreenMode )
     {
         QPainter painter( this );
         painter.fillRect( pe->rect(), Qt::black );
         return;
     }
 
     if ( !m_isSetup )
     {
         m_width = width();
         m_height = height();
         
         connect(m_document, &Okular::Document::linkFind, this, &PresentationWidget::slotFind);
 
         // register this observer in document. events will come immediately
         m_document->addObserver( this );
 
         // show summary if requested
         if ( Okular::Settings::slidesShowSummary() )
             generatePage();
     }
     qDebug() << "PW: width" << m_width << "height" << m_height;
     
     // check painting rect consistancy
     QRect r = pe->rect().intersected( QRect( QPoint( 0, 0 ), geometry().size() ) );
     if ( r.isNull() )
         return;
 
     if ( m_lastRenderedPixmap.isNull() )
     {
         QPainter painter( this );
         painter.fillRect( pe->rect(), Okular::Settings::slidesBackgroundColor() );
         return;
     }
 
     m_lastRenderedPixmap.save("/tmp/paint/pw_last.png");
     
     // blit the pixmap to the screen
     QVector<QRect> allRects = pe->region().rects();
     uint numRects = allRects.count();
     QPainter painter( this );
     for ( uint i = 0; i < numRects; i++ )
     {
         const QRect & r = allRects[i];
         if ( !r.isValid() )
             continue;
 #ifdef ENABLE_PROGRESS_OVERLAY
         const QRect dR(QRectF(r.x() * dpr, r.y() * dpr, r.width() * dpr, r.height() * dpr).toAlignedRect());
         if ( Okular::Settings::slidesShowProgress() && r.intersects( m_overlayGeometry ) )
         {
             // backbuffer the overlay operation
             QPixmap backPixmap( dR.size() );
             backPixmap.setDevicePixelRatio( dpr );
             QPainter pixPainter( &backPixmap );
 
             // first draw the background on the backbuffer
             pixPainter.drawPixmap( QPoint(0,0), m_lastRenderedPixmap, dR );
 
             // then blend the overlay (a piece of) over the background
             m_lastRenderedOverlay.save("/tmp/overlay.png");
             QRect ovr = m_overlayGeometry.intersected( r );
             pixPainter.drawPixmap( (ovr.left() - r.left()), (ovr.top() - r.top()),
                 m_lastRenderedOverlay, (ovr.left() - m_overlayGeometry.left()) * dpr,
                 (ovr.top() - m_overlayGeometry.top()) * dpr, ovr.width() * dpr, ovr.height() * dpr );
 
             // finally blit the pixmap to the screen
             pixPainter.end();
             const QRect backPixmapRect = backPixmap.rect();
             const QRect dBackPixmapRect(QRectF(backPixmapRect.x() * dpr, backPixmapRect.y() * dpr, backPixmapRect.width() * dpr, backPixmapRect.height() * dpr).toAlignedRect());
             painter.drawPixmap( r.topLeft(), backPixmap, dBackPixmapRect );
         } else
 #endif
         // copy the rendered pixmap to the screen
             painter.drawPixmap( r.topLeft(), m_lastRenderedPixmap, dR );
         
         qDebug() << "m_lastRenderedPixmap DPR" << m_lastRenderedPixmap.devicePixelRatioF();
     }
 
     // paint drawings
     if ( m_frameIndex != -1 )
     {
         painter.save();
 
         const QRect & geom = m_frames[ m_frameIndex ]->geometry;
 
         QPixmap pm( geom.size() );
         pm.fill( Qt::transparent );
         QPainter pmPainter( &pm );
 
         pmPainter.setRenderHints( QPainter::Antialiasing );
         foreach ( const SmoothPath &drawing, m_frames[ m_frameIndex ]->drawings )
             drawing.paint( &pmPainter, geom.width(), geom.height() );
 
         if ( m_drawingEngine && m_drawingRect.intersects( pe->rect() ) )
             m_drawingEngine->paint( &pmPainter, geom.width(), geom.height(), m_drawingRect.intersected( pe->rect() ) );
 
         painter.setRenderHints( QPainter::Antialiasing );
         painter.drawPixmap( geom.topLeft() , pm );
 
         painter.restore();
     }
     painter.end();
 }
 
 void PresentationWidget::resizeEvent( QResizeEvent *re )
 {
     // qCDebug(OkularUiDebug) << re->oldSize() << "=>" << re->size();
     if ( re->oldSize() == QSize( -1, -1 ) )
         return;
 
     m_screen = QApplication::desktop()->screenNumber( this );
 
     applyNewScreenSize( re->oldSize() );
 }
 
 void PresentationWidget::leaveEvent( QEvent * e )
 {
     Q_UNUSED( e )
 
     if ( !m_topBar->isHidden() )
     {
         showTopBar( false );
     }
 }
 // </widget events>
 
 const void * PresentationWidget::getObjectRect( Okular::ObjectRect::ObjectType type, int x, int y, QRect * geometry ) const
 {
     // no links on invalid pages
     if ( geometry && !geometry->isNull() )
         geometry->setRect( 0, 0, 0, 0 );
     if ( m_frameIndex < 0 || m_frameIndex >= (int)m_frames.size() )
         return 0;
 
     // get frame, page and geometry
     const PresentationFrame * frame = m_frames[ m_frameIndex ];
     const Okular::Page * page = frame->page;
     const QRect & frameGeometry = frame->geometry;
 
     // compute normalized x and y
     double nx = (double)(x - frameGeometry.left()) / (double)frameGeometry.width();
     double ny = (double)(y - frameGeometry.top()) / (double)frameGeometry.height();
 
     // no links outside the pages
     if ( nx < 0 || nx > 1 || ny < 0 || ny > 1 )
         return 0;
 
     // check if 1) there is an object and 2) it's a link
     const QRect d = QApplication::desktop()->screenGeometry( m_screen );
     const Okular::ObjectRect * object = page->objectRect( type, nx, ny, d.width(), d.height() );
     if ( !object )
         return 0;
 
     // compute link geometry if destination rect present
     if ( geometry )
     {
         *geometry = object->boundingRect( frameGeometry.width(), frameGeometry.height() );
         geometry->translate( frameGeometry.left(), frameGeometry.top() );
     }
 
     // return the link pointer
     return object->object();
 }
 
 const Okular::Action * PresentationWidget::getLink( int x, int y, QRect * geometry ) const
 {
     return reinterpret_cast<const Okular::Action*>( getObjectRect( Okular::ObjectRect::Action, x, y, geometry ) );
 }
 
 const Okular::Annotation * PresentationWidget::getAnnotation( int x, int y, QRect * geometry ) const
 {
     return reinterpret_cast<const Okular::Annotation*>( getObjectRect( Okular::ObjectRect::OAnnotation, x, y, geometry ) );
 }
 
 void PresentationWidget::testCursorOnLink( int x, int y )
 {
     const Okular::Action * link = getLink( x, y, 0 );
     const Okular::Annotation *annotation = getAnnotation( x, y, 0 );
 
     const bool needsHandCursor = ( ( link != 0 ) ||
                                  ( ( annotation != 0 ) && ( annotation->subType() == Okular::Annotation::AMovie ) ) ||
                                  ( ( annotation != 0 ) && ( annotation->subType() == Okular::Annotation::ARichMedia ) ) ||
                                  ( ( annotation != 0 ) && ( annotation->subType() == Okular::Annotation::AScreen ) && ( GuiUtils::renditionMovieFromScreenAnnotation( static_cast< const Okular::ScreenAnnotation * >( annotation ) ) != 0 ) ) );
 
     // only react on changes (in/out from a link)
     if ( ( needsHandCursor && !m_handCursor ) || ( !needsHandCursor && m_handCursor ) )
     {
         // change cursor shape
         m_handCursor = needsHandCursor;
         setCursor( QCursor( m_handCursor ? Qt::PointingHandCursor : Qt::ArrowCursor ) );
     }
 }
 
 void PresentationWidget::overlayClick( const QPoint & position )
 {
     // clicking the progress indicator
     int xPos = position.x() - m_overlayGeometry.x() - m_overlayGeometry.width() / 2,
         yPos = m_overlayGeometry.height() / 2 - position.y();
     if ( !xPos && !yPos )
         return;
 
     // compute angle relative to indicator (note coord transformation)
     float angle = 0.5 + 0.5 * atan2( (double)-xPos, (double)-yPos ) / M_PI;
     int pageIndex = (int)( angle * ( m_frames.count() - 1 ) + 0.5 );
 
     // go to selected page
     changePage( pageIndex );
 }
 
 void PresentationWidget::changePage( int newPage )
 {
     if ( m_showSummaryView ) {
         m_showSummaryView = false;
         m_frameIndex = -1;
         return;
     }
 
     if ( m_frameIndex == newPage )
         return;
 
     // switch to newPage
     m_document->setViewportPage( newPage, this );
 
     if ( (Okular::Settings::slidesShowSummary() && !m_showSummaryView) || m_frameIndex == -1 )
         notifyCurrentPageChanged( -1, newPage );
 }
 
 void PresentationWidget::generatePage( bool disableTransition )
 {
     if ( m_lastRenderedPixmap.isNull() )
     {
         qreal dpr = qApp->devicePixelRatio();
         m_lastRenderedPixmap = QPixmap( m_width * dpr, m_height * dpr );
         m_lastRenderedPixmap.setDevicePixelRatio(dpr);
 
         m_previousPagePixmap = QPixmap();
     }
     else
     {
         m_previousPagePixmap = m_lastRenderedPixmap;
     }
     
     
 
     // opens the painter over the pixmap
     QPainter pixmapPainter;
     pixmapPainter.begin( &m_lastRenderedPixmap );
     // generate welcome page
     if ( m_frameIndex == -1 )
         generateIntroPage( pixmapPainter );
     // generate a normal pixmap with extended margin filling
     if ( m_frameIndex >= 0 && m_frameIndex < (int)m_document->pages() )
         generateContentsPage( m_frameIndex, pixmapPainter );
     pixmapPainter.end();
 
     // generate the top-right corner overlay
 #ifdef ENABLE_PROGRESS_OVERLAY
     if ( Okular::Settings::slidesShowProgress() && m_frameIndex != -1 )
         generateOverlay();
 #endif
 
     // start transition on pages that have one
     if ( !disableTransition && Okular::Settings::slidesTransitionsEnabled() )
     {
         const Okular::PageTransition * transition = m_frameIndex != -1 ?
             m_frames[ m_frameIndex ]->page->transition() : 0;
         if ( transition )
             initTransition( transition );
         else {
             Okular::PageTransition trans = defaultTransition();
             initTransition( &trans );
         }
     }
     else
     {
         Okular::PageTransition trans = defaultTransition( Okular::Settings::EnumSlidesTransition::Replace );
         initTransition( &trans );
     }
 
     // update cursor + tooltip
     if ( !m_drawingEngine && Okular::Settings::slidesCursor() != Okular::Settings::EnumSlidesCursor::Hidden )
     {
         QPoint p = mapFromGlobal( QCursor::pos() );
         testCursorOnLink( p.x(), p.y() );
     }
 }
 
 void PresentationWidget::generateIntroPage( QPainter & p )
 {
     qreal dpr = qApp->devicePixelRatio();
     
     // use a vertical gray gradient background
     int blend1 = m_height / 10,
         blend2 = 9 * m_height / 10;
     int baseTint = QColor(Qt::gray).red();
     for ( int i = 0; i < m_height; i++ )
     {
         int k = baseTint;
         if ( i < blend1 )
             k -= (int)( baseTint * (i-blend1)*(i-blend1) / (float)(blend1 * blend1) );
         if ( i > blend2 )
             k += (int)( (255-baseTint) * (i-blend2)*(i-blend2) / (float)(blend1 * blend1) );
         p.fillRect( 0, i, m_width, 1, QColor( k, k, k ) );
     }
 
     // draw okular logo in the four corners
     QPixmap logo = DesktopIcon( QStringLiteral("okular"), 64 * dpr );
     logo.setDevicePixelRatio( dpr );
     if ( !logo.isNull() )
     {
         p.drawPixmap( 5, 5, logo );
         p.drawPixmap( m_width - 5 - logo.width(), 5, logo );
         p.drawPixmap( m_width - 5 - logo.width(), m_height - 5 - logo.height(), logo );
         p.drawPixmap( 5, m_height - 5 - logo.height(), logo );
     }
 
     // draw metadata text (the last line is 'click to begin')
     int strNum = m_metaStrings.count(),
         strHeight = m_height / ( strNum + 4 ),
         fontHeight = 2 * strHeight / 3;
     QFont font( p.font() );
     font.setPixelSize( fontHeight );
     QFontMetrics metrics( font );
     for ( int i = 0; i < strNum; i++ )
     {
         // set a font to fit text width
         float wScale = (float)metrics.boundingRect( m_metaStrings[i] ).width() / (float)m_width;
         QFont f( font );
         if ( wScale > 1.0 )
             f.setPixelSize( (int)( (float)fontHeight / (float)wScale ) );
         p.setFont( f );
 
         // text shadow
         p.setPen( Qt::darkGray );
         p.drawText( 2, m_height / 4 + strHeight * i + 2, m_width, strHeight,
                     Qt::AlignHCenter | Qt::AlignVCenter, m_metaStrings[i] );
         // text body
         p.setPen( 128 + (127 * i) / strNum );
         p.drawText( 0, m_height / 4 + strHeight * i, m_width, strHeight,
                     Qt::AlignHCenter | Qt::AlignVCenter, m_metaStrings[i] );
     }
 }
 
 void PresentationWidget::generateContentsPage( int pageNum, QPainter & p )
 {
     PresentationFrame * frame = m_frames[ pageNum ];
 
     // translate painter and contents rect
     QRect geom( frame->geometry );
     p.translate( geom.left(), geom.top() );
     geom.translate( -geom.left(), -geom.top() );
 
     // draw the page using the shared PagePainter class
     int flags = PagePainter::Accessibility | PagePainter::Highlights | PagePainter::Annotations;
     
     qDebug() << "PW paintPageOnPainter" << geom.width() << geom.height() << geom;
     
     PagePainter::paintPageOnPainter( &p, frame->page, this, flags,
                                      geom.width(), geom.height(), geom );
 
     // restore painter
     p.translate( -frame->geometry.left(), -frame->geometry.top() );
 
     // fill unpainted areas with background color
     QRegion unpainted( QRect( 0, 0, m_width, m_height ) );
     QVector<QRect> rects = unpainted.subtracted( frame->geometry ).rects();
     for ( int i = 0; i < rects.count(); i++ )
     {
         const QRect & r = rects[i];
         p.fillRect( r, Okular::Settings::slidesBackgroundColor() );
     }
 }
 
 // from Arthur - Qt4 - (is defined elsewhere as 'qt_div_255' to not break final compilation)
 inline int qt_div255(int x) { return (x + (x>>8) + 0x80) >> 8; }
 void PresentationWidget::generateOverlay()
 {
 #ifdef ENABLE_PROGRESS_OVERLAY
     qreal dpr = qApp->devicePixelRatio();
     
     // calculate overlay geometry and resize pixmap if needed
     int side = m_width / 16;
     m_overlayGeometry.setRect( m_width - side - 4, 4, side, side );
 
     // note: to get a sort of antialiasing, we render the pixmap double sized
     // and the resulting image is smoothly scaled down. So here we open a
     // painter on the double sized pixmap.
     side *= 2;
     
     QPixmap doublePixmap( side * dpr, side * dpr );
     doublePixmap.setDevicePixelRatio( dpr );
     doublePixmap.fill( Qt::black );
     QPainter pixmapPainter( &doublePixmap );
     pixmapPainter.setRenderHints( QPainter::Antialiasing );
 
     // draw PIE SLICES in blue levels (the levels will then be the alpha component)
     int pages = m_document->pages();
     if ( pages > 28 )
     {   // draw continuous slices
         int degrees = (int)( 360 * (float)(m_frameIndex + 1) / (float)pages );
         pixmapPainter.setPen( 0x05 );
         pixmapPainter.setBrush( QColor( 0x40 ) );
         pixmapPainter.drawPie( 2, 2, side - 4, side - 4, 90*16, (360-degrees)*16 );
         pixmapPainter.setPen( 0x40 );
         pixmapPainter.setBrush( QColor( 0xF0 ) );
         pixmapPainter.drawPie( 2, 2, side - 4, side - 4, 90*16, -degrees*16 );
     }
     else
     {   // draw discrete slices
         float oldCoord = -90;
         for ( int i = 0; i < pages; i++ )
         {
             float newCoord = -90 + 360 * (float)(i + 1) / (float)pages;
             pixmapPainter.setPen( i <= m_frameIndex ? 0x40 : 0x05 );
             pixmapPainter.setBrush( QColor( i <= m_frameIndex ? 0xF0 : 0x40 ) );
             pixmapPainter.drawPie( 2, 2, side - 4, side - 4,
                                    (int)( -16*(oldCoord + 1) ), (int)( -16*(newCoord - (oldCoord + 2)) ) );
             oldCoord = newCoord;
         }
     }
     int circleOut = side / 4;
     pixmapPainter.setPen( Qt::black );
     pixmapPainter.setBrush( Qt::black );
     pixmapPainter.drawEllipse( circleOut, circleOut, side - 2*circleOut, side - 2*circleOut );
 
     // draw TEXT using maximum opacity
     QFont f( pixmapPainter.font() );
     f.setPixelSize( side / 4 );
     pixmapPainter.setFont( f );
     pixmapPainter.setPen( 0xFF );
     // use a little offset to prettify output
     pixmapPainter.drawText( 2, 2, side, side, Qt::AlignCenter, QString::number( m_frameIndex + 1 ) );
 
     // end drawing pixmap and halve image
     pixmapPainter.end();
     QImage image( doublePixmap.toImage().scaled( (side / 2) * dpr, (side / 2) * dpr, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ) );
     image.setDevicePixelRatio( dpr );
     image = image.convertToFormat( QImage::Format_ARGB32 );
     image.setDevicePixelRatio( dpr );
 
     // draw circular shadow using the same technique
     doublePixmap.fill( Qt::black );
     pixmapPainter.begin( &doublePixmap );
     pixmapPainter.setPen( 0x40 );
     pixmapPainter.setBrush( QColor( 0x80 ) );
     pixmapPainter.drawEllipse( 0, 0, side, side );
     pixmapPainter.end();
     QImage shadow( doublePixmap.toImage().scaled( (side / 2) * dpr, (side / 2) * dpr, Qt::IgnoreAspectRatio, Qt::SmoothTransformation ) );
     shadow.setDevicePixelRatio( dpr );
     
     // generate a 2 colors pixmap using mixing shadow (made with highlight color)
     // and image (made with highlightedText color)
     QPalette pal = palette();
     QColor color = pal.color( QPalette::Active, QPalette::HighlightedText );
     int red = color.red(), green = color.green(), blue = color.blue();
     color = pal.color( QPalette::Active, QPalette::Highlight );
     int sRed = color.red(), sGreen = color.green(), sBlue = color.blue();
     // pointers
     unsigned int * data = (unsigned int *)image.bits(),
                  * shadowData = (unsigned int *)shadow.bits(),
                  pixels = image.width() * image.height();
     // cache data (reduce computation time to 26%!)
     int c1 = -1, c2 = -1, cR = 0, cG = 0, cB = 0, cA = 0;
     // foreach pixel
     for( unsigned int i = 0; i < pixels; ++i )
     {
         // alpha for shadow and image
         int shadowAlpha = shadowData[i] & 0xFF,
             srcAlpha = data[i] & 0xFF;
         // cache values
         if ( srcAlpha != c1 || shadowAlpha != c2 )
         {
             c1 = srcAlpha;
             c2 = shadowAlpha;
             // fuse color components and alpha value of image over shadow
             data[i] = qRgba(
                 cR = qt_div255( srcAlpha * red   + (255 - srcAlpha) * sRed ),
                 cG = qt_div255( srcAlpha * green + (255 - srcAlpha) * sGreen ),
                 cB = qt_div255( srcAlpha * blue  + (255 - srcAlpha) * sBlue ),
                 cA = qt_div255( srcAlpha * srcAlpha + (255 - srcAlpha) * shadowAlpha )
             );
         }
         else
             data[i] = qRgba( cR, cG, cB, cA );
     }
     m_lastRenderedOverlay = QPixmap::fromImage( image );
     m_lastRenderedOverlay.setDevicePixelRatio( dpr );
 
     // start the autohide timer
     //repaint( m_overlayGeometry ); // toggle with next line
     update( m_overlayGeometry );
     m_overlayHideTimer->start( 2500 );
 #endif
 }
 
 
 QRect PresentationWidget::routeMouseDrawingEvent( QMouseEvent * e )
 {
     if ( m_frameIndex == -1 ) // Can't draw on the summary page
         return QRect();
 
     const QRect & geom = m_frames[ m_frameIndex ]->geometry;
     const Okular::Page * page = m_frames[ m_frameIndex ]->page;
 
     AnnotatorEngine::EventType eventType;
     AnnotatorEngine::Button button;
 
     // figure out the event type and button
     AnnotatorEngine::decodeEvent( e, &eventType, &button );
 
     static bool hasclicked = false;
     if ( eventType == AnnotatorEngine::Press )
         hasclicked = true;
 
     double nX = ( (double)e->x() - (double)geom.left() ) / (double)geom.width();
     double nY = ( (double)e->y() - (double)geom.top() ) / (double)geom.height();
     QRect ret;
     bool isInside = nX >= 0 && nX < 1 && nY >= 0 && nY < 1;
 
     if ( hasclicked && !isInside ) {
         // Fake a move to the last border pos
         nX = qBound(0., nX, 1.);
         nY = qBound(0., nY, 1.);
         m_drawingEngine->event( AnnotatorEngine::Move, button, nX, nY, geom.width(), geom.height(), page );
 
         // Fake a release in the following lines
         eventType = AnnotatorEngine::Release;
         isInside = true;
     } else if ( !hasclicked && isInside )
     {
         // we're coming from the outside, pretend we started clicking at the closest border
         if ( nX < ( 1 - nX ) && nX < nY && nX < ( 1 - nY ) )
             nX = 0;
         else if ( nY < ( 1 - nY ) && nY < nX && nY < ( 1 - nX ) )
             nY = 0;
         else if ( ( 1 - nX ) < nX && ( 1 - nX ) < nY && ( 1 - nX ) < ( 1 - nY ) )
             nX = 1;
         else
             nY = 1;
 
         hasclicked = true;
         eventType = AnnotatorEngine::Press;
     }
 
     if ( hasclicked && isInside )
     {
         ret = m_drawingEngine->event( eventType, button, nX, nY, geom.width(), geom.height(), page );
     }
 
     if ( eventType == AnnotatorEngine::Release )
     {
         hasclicked = false;
     }
 
     if ( m_drawingEngine->creationCompleted() )
     {
         // add drawing to current page
         m_frames[ m_frameIndex ]->drawings << m_drawingEngine->endSmoothPath();
 
         // manually disable and re-enable the pencil mode, so we can do
         // cleaning of the actual drawer and create a new one just after
         // that - that gives continuous drawing
         slotChangeDrawingToolEngine( QDomElement() );
         slotChangeDrawingToolEngine( m_currentDrawingToolElement );
 
         // schedule repaint
         update();
     }
 
     return ret;
 }
 
 void PresentationWidget::startAutoChangeTimer()
 {
     double pageDuration = m_frameIndex >= 0 && m_frameIndex < (int)m_frames.count() ? m_frames[ m_frameIndex ]->page->duration() : -1;
     if ( m_advanceSlides || pageDuration >= 0.0 )
     {
         double secs;
         if ( pageDuration < 0.0 )
             secs = Okular::SettingsCore::slidesAdvanceTime();
         else if ( m_advanceSlides )
             secs = qMin<double>( pageDuration, Okular::SettingsCore::slidesAdvanceTime() );
         else
             secs = pageDuration;
 
         m_nextPageTimer->start( (int)( secs * 1000 ) );
     }
 }
 
 void PresentationWidget::recalcGeometry()
 {
     QDesktopWidget *desktop = QApplication::desktop();
     const int preferenceScreen = Okular::Settings::slidesScreen();
     int screen = 0;
     if ( preferenceScreen == -2 )
     {
         screen = desktop->screenNumber( m_parentWidget );
     }
     else if ( preferenceScreen == -1 )
     {
         screen = desktop->primaryScreen();
     }
     else if ( preferenceScreen >= 0 && preferenceScreen < desktop->numScreens() )
     {
         screen = preferenceScreen;
     }
     else
     {
         screen = desktop->screenNumber( m_parentWidget );
         Okular::Settings::setSlidesScreen( -2 );
     }
     const QRect screenGeom = desktop->screenGeometry( screen );
     // qCDebug(OkularUiDebug) << screen << "=>" << screenGeom;
     m_screen = screen;
     setGeometry( screenGeom );
 }
 
 void PresentationWidget::repositionContent()
 {
     const QRect ourGeom = geometry();
 
     // tool bar height in pixels, make it large enough to hold the text fields with the page numbers
     const int toolBarHeight = m_pagesEdit->height() * 1.5;
 
     m_topBar->setGeometry( 0, 0, ourGeom.width(), toolBarHeight );
     m_topBar->setIconSize( QSize( toolBarHeight * 0.75, toolBarHeight * 0.75 ) );
 
 }
 
 void PresentationWidget::requestPixmaps()
 {
     PresentationFrame * frame = m_frames[ m_frameIndex ];
     int pixW = frame->geometry.width();
     int pixH = frame->geometry.height();
 
     // operation will take long: set busy cursor
     QApplication::setOverrideCursor( QCursor( Qt::BusyCursor ) );
     // request the pixmap
     QLinkedList< Okular::PixmapRequest * > requests;
     qDebug() << "PW PixmapRequest" << devicePixelRatioF();
-    requests.push_back( new Okular::PixmapRequest( this, m_frameIndex, pixW, pixH, devicePixelRatioF(), PRESENTATION_PRIO, Okular::PixmapRequest::NoFeature ) );
+    requests.push_back( new Okular::PixmapRequest( this, m_frameIndex, pixW, pixH, PRESENTATION_PRIO, Okular::PixmapRequest::NoFeature ) );
     // restore cursor
     QApplication::restoreOverrideCursor();
     // ask for next and previous page if not in low memory usage setting
     if ( Okular::SettingsCore::memoryLevel() != Okular::SettingsCore::EnumMemoryLevel::Low )
     {
         int pagesToPreload = 1;
 
         // If greedy, preload everything
         if (Okular::SettingsCore::memoryLevel() == Okular::SettingsCore::EnumMemoryLevel::Greedy)
             pagesToPreload = (int)m_document->pages();
 
         Okular::PixmapRequest::PixmapRequestFeatures requestFeatures = Okular::PixmapRequest::Preload;
         requestFeatures |= Okular::PixmapRequest::Asynchronous;
 
         for( int j = 1; j <= pagesToPreload; j++ )
         {
             int tailRequest = m_frameIndex + j;
             if ( tailRequest < (int)m_document->pages() )
             {
                 PresentationFrame *nextFrame = m_frames[ tailRequest ];
                 pixW = nextFrame->geometry.width();
                 pixH = nextFrame->geometry.height();
                 if ( !nextFrame->page->hasPixmap( this, pixW, pixH ) )
-                    requests.push_back( new Okular::PixmapRequest( this, tailRequest, pixW, pixH, devicePixelRatioF(), PRESENTATION_PRELOAD_PRIO, requestFeatures ) );
+                    requests.push_back( new Okular::PixmapRequest( this, tailRequest, pixW, pixH, PRESENTATION_PRELOAD_PRIO, requestFeatures ) );
             }
 
             int headRequest = m_frameIndex - j;
             if ( headRequest >= 0 )
             {
                 PresentationFrame *prevFrame = m_frames[ headRequest ];
                 pixW = prevFrame->geometry.width();
                 pixH = prevFrame->geometry.height();
                 if ( !prevFrame->page->hasPixmap( this, pixW, pixH ) )
-                    requests.push_back( new Okular::PixmapRequest( this, headRequest, pixW, pixH, devicePixelRatioF(), PRESENTATION_PRELOAD_PRIO, requestFeatures ) );
+                    requests.push_back( new Okular::PixmapRequest( this, headRequest, pixW, pixH, PRESENTATION_PRELOAD_PRIO, requestFeatures ) );
             }
 
             // stop if we've already reached both ends of the document
             if ( headRequest < 0 && tailRequest >= (int)m_document->pages() )
                 break;
         }
     }
     m_document->requestPixmaps( requests );
 }
 
 
 void PresentationWidget::slotNextPage()
 {
     int nextIndex = m_frameIndex + 1;
 
     // loop when configured
     if ( nextIndex == m_frames.count() && Okular::Settings::slidesLoop() )
         nextIndex = 0;
 
     if ( nextIndex < m_frames.count() )
     {
         // go to next page
         changePage( nextIndex );
         // auto advance to the next page if set
         startAutoChangeTimer();
     }
     else
     {
 #ifdef ENABLE_PROGRESS_OVERLAY
         if ( Okular::Settings::slidesShowProgress() )
             generateOverlay();
 #endif
         if ( m_transitionTimer->isActive() )
         {
             m_transitionTimer->stop();
             m_lastRenderedPixmap = m_currentPagePixmap;
             update();
         }
     }
     // we need the setFocus() call here to let KCursor::autoHide() work correctly
     setFocus();
 }
 
 void PresentationWidget::slotPrevPage()
 {
     if ( m_frameIndex > 0 )
     {
         // go to previous page
         changePage( m_frameIndex - 1 );
 
         // auto advance to the next page if set
         startAutoChangeTimer();
     }
     else
     {
 #ifdef ENABLE_PROGRESS_OVERLAY
         if ( Okular::Settings::slidesShowProgress() )
             generateOverlay();
 #endif
         if ( m_transitionTimer->isActive() )
         {
             m_transitionTimer->stop();
             m_lastRenderedPixmap = m_currentPagePixmap;
             update();
         }
     }
 }
 
 void PresentationWidget::slotFirstPage()
 {
     changePage( 0 );
 }
 
 void PresentationWidget::slotLastPage()
 {
     changePage( (int)m_frames.count() - 1 );
 }
 
 void PresentationWidget::slotHideOverlay()
 {
     QRect geom( m_overlayGeometry );
     m_overlayGeometry.setCoords( 0, 0, -1, -1 );
     update( geom );
 }
 
 void PresentationWidget::slotTransitionStep()
 {
     switch( m_currentTransition.type() )
     {
         case Okular::PageTransition::Fade:
         {
             QPainter pixmapPainter;
             m_currentPixmapOpacity += 1.0 / m_transitionSteps;
             m_lastRenderedPixmap = QPixmap( m_lastRenderedPixmap.size() );
             m_lastRenderedPixmap.setDevicePixelRatio( qApp->devicePixelRatio() );
             m_lastRenderedPixmap.fill( Qt::transparent );
             pixmapPainter.begin( &m_lastRenderedPixmap );
             pixmapPainter.setCompositionMode( QPainter::CompositionMode_Source );
             pixmapPainter.setOpacity( 1 - m_currentPixmapOpacity );
             pixmapPainter.drawPixmap( 0, 0, m_previousPagePixmap );
             pixmapPainter.setOpacity( m_currentPixmapOpacity );
             pixmapPainter.drawPixmap( 0, 0, m_currentPagePixmap );
             update();
             if( m_currentPixmapOpacity >= 1 )
                 return;
         } break;
         default:
         {
             if ( m_transitionRects.empty() )
             {
                 // it's better to fix the transition to cover the whole screen than
                 // enabling the following line that wastes cpu for nothing
                 //update();
                 return;
             }
 
             for ( int i = 0; i < m_transitionMul && !m_transitionRects.empty(); i++ )
             {
                 update( m_transitionRects.first() );
                 m_transitionRects.pop_front();
             }
         } break;
     }
     m_transitionTimer->start( m_transitionDelay );
 }
 
 void PresentationWidget::slotDelayedEvents()
 {
     recalcGeometry();
     repositionContent();
 
     if ( m_screenSelect )
     {
         m_screenSelect->setCurrentItem( m_screen );
         connect( m_screenSelect->selectableActionGroup(), &QActionGroup::triggered,
                  this, &PresentationWidget::chooseScreen );
     }
 
     // show widget and take control
     show();
     setWindowState( windowState() | Qt::WindowFullScreen );
 
     connect( QApplication::desktop(), &QDesktopWidget::resized, this, &PresentationWidget::screenResized );
 
   // inform user on how to exit from presentation mode
   KMessageBox::information( this, i18n("There are two ways of exiting presentation mode, you can press either ESC key or click with the quit button that appears when placing the mouse in the top-right corner. Of course you can cycle windows (Alt+TAB by default)"), QString(), QStringLiteral("presentationInfo") );
 }
 
 void PresentationWidget::slotPageChanged()
 {
     bool ok = true;
     int p = m_pagesEdit->text().toInt( &ok );
     if ( !ok )
         return;
 
     changePage( p - 1 );
 }
 
 void PresentationWidget::slotChangeDrawingToolEngine( const QDomElement &element )
 {
     if ( element.isNull() )
     {
         delete m_drawingEngine;
         m_drawingEngine = 0;
         m_drawingRect = QRect();
         setCursor( Qt::ArrowCursor );
     }
     else
     {
         m_drawingEngine = new SmoothPathEngine( element );
         setCursor( QCursor( QPixmap( QStringLiteral("pencil") ), Qt::ArrowCursor ) );
         m_currentDrawingToolElement = element;
     }
 }
 
 void PresentationWidget::slotAddDrawingToolActions()
 {
     DrawingToolActions *drawingToolActions = qobject_cast<DrawingToolActions*>(sender());
     foreach(QAction *action, drawingToolActions->actions()) {
         action->setEnabled( true );
         m_topBar->addAction( action );
         addAction( action );
     }
 }
 
 void PresentationWidget::clearDrawings()
 {
     if ( m_frameIndex != -1 )
         m_frames[ m_frameIndex ]->drawings.clear();
     update();
 }
 
 void PresentationWidget::screenResized( int screen )
 {
     // we can ignore if a screen was resized in the case the screen is not
     // where we are on
     if ( screen != m_screen )
         return;
 
     setScreen( screen );
 }
 
 void PresentationWidget::chooseScreen( QAction *act )
 {
     if ( !act || act->data().type() != QVariant::Int )
         return;
 
     const int newScreen = act->data().toInt();
 
     setScreen( newScreen );
 }
 
 void PresentationWidget::toggleBlackScreenMode( bool )
 {
     m_inBlackScreenMode = !m_inBlackScreenMode;
 
     update();
 }
 
 void PresentationWidget::setScreen( int newScreen )
 {
     const QRect screenGeom = QApplication::desktop()->screenGeometry( newScreen );
     const QSize oldSize = size();
     // qCDebug(OkularUiDebug) << newScreen << "=>" << screenGeom;
     m_screen = newScreen;
     setGeometry( screenGeom );
 
     applyNewScreenSize( oldSize );
 }
 
 void PresentationWidget::applyNewScreenSize( const QSize & oldSize )
 {
     repositionContent();
 
     // if by chance the new screen has the same resolution of the previous,
     // do not invalidate pixmaps and such..
     if ( size() == oldSize )
         return;
 
     m_width = width();
     m_height = height();
 
     // update the frames
     QVector< PresentationFrame * >::const_iterator fIt = m_frames.constBegin(), fEnd = m_frames.constEnd();
     const float screenRatio = (float)m_height / (float)m_width;
     for ( ; fIt != fEnd; ++fIt )
     {
         (*fIt)->recalcGeometry( m_width, m_height, screenRatio, qApp->devicePixelRatio() );
     }
 
     if ( m_frameIndex != -1 )
     {
     // ugliness alarm!
     const_cast< Okular::Page * >( m_frames[ m_frameIndex ]->page )->deletePixmap( this );
     // force the regeneration of the pixmap
     m_lastRenderedPixmap = QPixmap();
     m_blockNotifications = true;
     requestPixmaps();
     m_blockNotifications = false;
     }
     if ( m_transitionTimer->isActive() )
     {
         m_transitionTimer->stop();
     }
     generatePage( true /* no transitions */ );
 }
 
 void PresentationWidget::inhibitPowerManagement()
 {
 #ifdef Q_OS_LINUX
     QString reason = i18nc( "Reason for inhibiting the screensaver activation, when the presentation mode is active", "Giving a presentation" );
 
     if (!m_screenInhibitCookie) {
         QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.ScreenSaver", "/ScreenSaver",
                                                               "org.freedesktop.ScreenSaver", "Inhibit");
         message << QCoreApplication::applicationName();
         message << reason;
 
         QDBusPendingReply<uint> reply = QDBusConnection::sessionBus().asyncCall(message);
         reply.waitForFinished();
         if (reply.isValid()) {
             m_screenInhibitCookie = reply.value();
             qCDebug(OkularUiDebug) << "Screen inhibition cookie" << m_screenInhibitCookie;
         } else {
             qCWarning(OkularUiDebug) << "Unable to inhibit screensaver" << reply.error();
         }
     }
 
     if (!m_sleepInhibitCookie) {
         QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.freedesktop.login1"),
                                                               QStringLiteral("/org/freedesktop/login1"),
                                                               QStringLiteral("org.freedesktop.login1.Manager"),
                                                               QStringLiteral("Inhibit")
                                                               );
         message << QStringLiteral("sleep");
         message << QCoreApplication::applicationName();
         message << reason;
         message << QStringLiteral("block");
 
         QDBusPendingReply<QDBusUnixFileDescriptor> reply = QDBusConnection::systemBus().asyncCall(message);
         reply.waitForFinished();
         if (reply.isValid()) {
             m_sleepInhibitCookie = reply.value().fileDescriptor();
         } else {
             qCWarning(OkularUiDebug) << "Unable to inhibit sleep" << reply.error();
         }
     }
 #endif
 }
 
 void PresentationWidget::allowPowerManagement()
 {
 #ifdef Q_OS_LINUX
     if (m_sleepInhibitCookie) {
         ::close(m_sleepInhibitCookie);
         m_sleepInhibitCookie = 0;
     }
 
     if (m_screenInhibitCookie) {
         QDBusMessage message = QDBusMessage::createMethodCall("org.freedesktop.ScreenSaver", "/ScreenSaver",
                                                               "org.freedesktop.ScreenSaver", "UnInhibit");
         message << m_screenInhibitCookie;
 
         QDBusPendingReply<uint> reply = QDBusConnection::sessionBus().asyncCall(message);
         reply.waitForFinished();
 
         m_screenInhibitCookie = 0;
     }
 #endif
 }
 
 void PresentationWidget::showTopBar( bool show )
 {
     if ( show )
     {
         m_topBar->show();
 
         // Don't autohide the mouse cursor if it's over the toolbar
         if ( Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay )
         {
             KCursor::setAutoHideCursor( this, false );
         }
 
         // Always show a cursor when topBar is visible
         if ( !m_drawingEngine )
         {
                 setCursor( QCursor( Qt::ArrowCursor ) );
         }
     }
     else
     {
         m_topBar->hide();
 
         // Reenable autohide if need be when leaving the toolbar
         if ( Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::HiddenDelay )
         {
             KCursor::setAutoHideCursor( this, true );
         }
 
         // Or hide the cursor again if hidden cursor is enabled
         else if ( Okular::Settings::slidesCursor() == Okular::Settings::EnumSlidesCursor::Hidden )
         {
             // Don't hide the cursor if drawing mode is on
             if ( !m_drawingEngine )
             {
                 setCursor( QCursor( Qt::BlankCursor ) );
             }
         }
     }
 
     // Make sure mouse tracking isn't off after the KCursor::setAutoHideCursor() calls
     setMouseTracking( true );
 }
 
 
 void PresentationWidget::slotFind()
 {
     if ( !m_searchBar )
     {
         m_searchBar = new PresentationSearchBar( m_document, this, this );
         m_searchBar->forceSnap();
     }
     m_searchBar->focusOnSearchEdit();
     m_searchBar->show();
 }
 
 
 const Okular::PageTransition PresentationWidget::defaultTransition() const
 {
     return defaultTransition( Okular::Settings::slidesTransition() );
 }
 
 const Okular::PageTransition PresentationWidget::defaultTransition( int type ) const
 {
     switch ( type )
     {
         case Okular::Settings::EnumSlidesTransition::BlindsHorizontal:
         {
             Okular::PageTransition transition( Okular::PageTransition::Blinds );
             transition.setAlignment( Okular::PageTransition::Horizontal );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::BlindsVertical:
         {
             Okular::PageTransition transition( Okular::PageTransition::Blinds );
             transition.setAlignment( Okular::PageTransition::Vertical );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::BoxIn:
         {
             Okular::PageTransition transition( Okular::PageTransition::Box );
             transition.setDirection( Okular::PageTransition::Inward );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::BoxOut:
         {
             Okular::PageTransition transition( Okular::PageTransition::Box );
             transition.setDirection( Okular::PageTransition::Outward );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::Dissolve:
         {
             return Okular::PageTransition( Okular::PageTransition::Dissolve );
             break;
         }
         case Okular::Settings::EnumSlidesTransition::GlitterDown:
         {
             Okular::PageTransition transition( Okular::PageTransition::Glitter );
             transition.setAngle( 270 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::GlitterRight:
         {
             Okular::PageTransition transition( Okular::PageTransition::Glitter );
             transition.setAngle( 0 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::GlitterRightDown:
         {
             Okular::PageTransition transition( Okular::PageTransition::Glitter );
             transition.setAngle( 315 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::Random:
         {
             return defaultTransition( KRandom::random() % 18 );
             break;
         }
         case Okular::Settings::EnumSlidesTransition::SplitHorizontalIn:
         {
             Okular::PageTransition transition( Okular::PageTransition::Split );
             transition.setAlignment( Okular::PageTransition::Horizontal );
             transition.setDirection( Okular::PageTransition::Inward );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::SplitHorizontalOut:
         {
             Okular::PageTransition transition( Okular::PageTransition::Split );
             transition.setAlignment( Okular::PageTransition::Horizontal );
             transition.setDirection( Okular::PageTransition::Outward );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::SplitVerticalIn:
         {
             Okular::PageTransition transition( Okular::PageTransition::Split );
             transition.setAlignment( Okular::PageTransition::Vertical );
             transition.setDirection( Okular::PageTransition::Inward );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::SplitVerticalOut:
         {
             Okular::PageTransition transition( Okular::PageTransition::Split );
             transition.setAlignment( Okular::PageTransition::Vertical );
             transition.setDirection( Okular::PageTransition::Outward );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::WipeDown:
         {
             Okular::PageTransition transition( Okular::PageTransition::Wipe );
             transition.setAngle( 270 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::WipeRight:
         {
             Okular::PageTransition transition( Okular::PageTransition::Wipe );
             transition.setAngle( 0 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::WipeLeft:
         {
             Okular::PageTransition transition( Okular::PageTransition::Wipe );
             transition.setAngle( 180 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::WipeUp:
         {
             Okular::PageTransition transition( Okular::PageTransition::Wipe );
             transition.setAngle( 90 );
             return transition;
             break;
         }
         case Okular::Settings::EnumSlidesTransition::Fade:
         {
             return Okular::PageTransition( Okular::PageTransition::Fade );
             break;
         }
         case Okular::Settings::EnumSlidesTransition::Replace:
         default:
             return Okular::PageTransition( Okular::PageTransition::Replace );
             break;
     }
     // should not happen, just make gcc happy
     return Okular::PageTransition();
 }
 
 /** ONLY the TRANSITIONS GENERATION function from here on **/
 void PresentationWidget::initTransition( const Okular::PageTransition *transition )
 {
     // if it's just a 'replace' transition, repaint the screen
     if ( transition->type() == Okular::PageTransition::Replace )
     {
         update();
         return;
     }
 
     const bool isInward = transition->direction() == Okular::PageTransition::Inward;
     const bool isHorizontal = transition->alignment() == Okular::PageTransition::Horizontal;
     const float totalTime = transition->duration();
 
     m_transitionRects.clear();
     m_currentTransition = *transition;
     m_currentPagePixmap = m_lastRenderedPixmap;
 
     switch( transition->type() )
     {
             // split: horizontal / vertical and inward / outward
         case Okular::PageTransition::Split:
         {
             const int steps = isHorizontal ? 100 : 75;
             if ( isHorizontal )
             {
                 if ( isInward )
                 {
                     int xPosition = 0;
                     for ( int i = 0; i < steps; i++ )
                     {
                         int xNext = ((i + 1) * m_width) / (2 * steps);
                         m_transitionRects.push_back( QRect( xPosition, 0, xNext - xPosition, m_height ) );
                         m_transitionRects.push_back( QRect( m_width - xNext, 0, xNext - xPosition, m_height ) );
                         xPosition = xNext;
                     }
                 }
                 else
                 {
                     int xPosition = m_width / 2;
                     for ( int i = 0; i < steps; i++ )
                     {
                         int xNext = ((steps - (i + 1)) * m_width) / (2 * steps);
                         m_transitionRects.push_back( QRect( xNext, 0, xPosition - xNext, m_height ) );
                         m_transitionRects.push_back( QRect( m_width - xPosition, 0, xPosition - xNext, m_height ) );
                         xPosition = xNext;
                     }
                 }
             }
             else
             {
                 if ( isInward )
                 {
                     int yPosition = 0;
                     for ( int i = 0; i < steps; i++ )
                     {
                         int yNext = ((i + 1) * m_height) / (2 * steps);
                         m_transitionRects.push_back( QRect( 0, yPosition, m_width, yNext - yPosition ) );
                         m_transitionRects.push_back( QRect( 0, m_height - yNext, m_width, yNext - yPosition ) );
                         yPosition = yNext;
                     }
                 }
                 else
                 {
                     int yPosition = m_height / 2;
                     for ( int i = 0; i < steps; i++ )
                     {
                         int yNext = ((steps - (i + 1)) * m_height) / (2 * steps);
                         m_transitionRects.push_back( QRect( 0, yNext, m_width, yPosition - yNext ) );
                         m_transitionRects.push_back( QRect( 0, m_height - yPosition, m_width, yPosition - yNext ) );
                         yPosition = yNext;
                     }
                 }
             }
             m_transitionMul = 2;
             m_transitionDelay = (int)( (totalTime * 1000) / steps );
         } break;
 
             // blinds: horizontal(l-to-r) / vertical(t-to-b)
         case Okular::PageTransition::Blinds:
         {
             const int blinds = isHorizontal ? 8 : 6;
             const int steps = m_width / (4 * blinds);
             if ( isHorizontal )
             {
                 int xPosition[ 8 ];
                 for ( int b = 0; b < blinds; b++ )
                     xPosition[ b ] = (b * m_width) / blinds;
 
                 for ( int i = 0; i < steps; i++ )
                 {
                     int stepOffset = (int)( ((float)i * (float)m_width) / ((float)blinds * (float)steps) );
                     for ( int b = 0; b < blinds; b++ )
                     {
                         m_transitionRects.push_back( QRect( xPosition[ b ], 0, stepOffset, m_height ) );
                         xPosition[ b ] = stepOffset + (b * m_width) / blinds;
                     }
                 }
             }
             else
             {
                 int yPosition[ 6 ];
                 for ( int b = 0; b < blinds; b++ )
                     yPosition[ b ] = (b * m_height) / blinds;
 
                 for ( int i = 0; i < steps; i++ )
                 {
                     int stepOffset = (int)( ((float)i * (float)m_height) / ((float)blinds * (float)steps) );
                     for ( int b = 0; b < blinds; b++ )
                     {
                         m_transitionRects.push_back( QRect( 0, yPosition[ b ], m_width, stepOffset ) );
                         yPosition[ b ] = stepOffset + (b * m_height) / blinds;
                     }
                 }
             }
             m_transitionMul = blinds;
             m_transitionDelay = (int)( (totalTime * 1000) / steps );
         } break;
 
             // box: inward / outward
         case Okular::PageTransition::Box:
         {
             const int steps = m_width / 10;
             if ( isInward )
             {
                 int L = 0, T = 0, R = m_width, B = m_height;
                 for ( int i = 0; i < steps; i++ )
                 {
                     // compure shrinked box coords
                     int newL = ((i + 1) * m_width) / (2 * steps);
                     int newT = ((i + 1) * m_height) / (2 * steps);
                     int newR = m_width - newL;
                     int newB = m_height - newT;
                     // add left, right, topcenter, bottomcenter rects
                     m_transitionRects.push_back( QRect( L, T, newL - L, B - T ) );
                     m_transitionRects.push_back( QRect( newR, T, R - newR, B - T ) );
                     m_transitionRects.push_back( QRect( newL, T, newR - newL, newT - T ) );
                     m_transitionRects.push_back( QRect( newL, newB, newR - newL, B - newB ) );
                     L = newL; T = newT; R = newR, B = newB;
                 }
             }
             else
             {
                 int L = m_width / 2, T = m_height / 2, R = L, B = T;
                 for ( int i = 0; i < steps; i++ )
                 {
                     // compure shrinked box coords
                     int newL = ((steps - (i + 1)) * m_width) / (2 * steps);
                     int newT = ((steps - (i + 1)) * m_height) / (2 * steps);
                     int newR = m_width - newL;
                     int newB = m_height - newT;
                     // add left, right, topcenter, bottomcenter rects
                     m_transitionRects.push_back( QRect( newL, newT, L - newL, newB - newT ) );
                     m_transitionRects.push_back( QRect( R, newT, newR - R, newB - newT ) );
                     m_transitionRects.push_back( QRect( L, newT, R - L, T - newT ) );
                     m_transitionRects.push_back( QRect( L, B, R - L, newB - B ) );
                     L = newL; T = newT; R = newR, B = newB;
                 }
             }
             m_transitionMul = 4;
             m_transitionDelay = (int)( (totalTime * 1000) / steps );
         } break;
 
             // wipe: implemented for 4 canonical angles
         case Okular::PageTransition::Wipe:
         {
             const int angle = transition->angle();
             const int steps = (angle == 0) || (angle == 180) ? m_width / 8 : m_height / 8;
             if ( angle == 0 )
             {
                 int xPosition = 0;
                 for ( int i = 0; i < steps; i++ )
                 {
                     int xNext = ((i + 1) * m_width) / steps;
                     m_transitionRects.push_back( QRect( xPosition, 0, xNext - xPosition, m_height ) );
                     xPosition = xNext;
                 }
             }
             else if ( angle == 90 )
             {
                 int yPosition = m_height;
                 for ( int i = 0; i < steps; i++ )
                 {
                     int yNext = ((steps - (i + 1)) * m_height) / steps;
                     m_transitionRects.push_back( QRect( 0, yNext, m_width, yPosition - yNext ) );
                     yPosition = yNext;
                 }
             }
             else if ( angle == 180 )
             {
                 int xPosition = m_width;
                 for ( int i = 0; i < steps; i++ )
                 {
                     int xNext = ((steps - (i + 1)) * m_width) / steps;
                     m_transitionRects.push_back( QRect( xNext, 0, xPosition - xNext, m_height ) );
                     xPosition = xNext;
                 }
             }
             else if ( angle == 270 )
             {
                 int yPosition = 0;
                 for ( int i = 0; i < steps; i++ )
                 {
                     int yNext = ((i + 1) * m_height) / steps;
                     m_transitionRects.push_back( QRect( 0, yPosition, m_width, yNext - yPosition ) );
                     yPosition = yNext;
                 }
             }
             else
             {
                 update();
                 return;
             }
             m_transitionMul = 1;
             m_transitionDelay = (int)( (totalTime * 1000) / steps );
         } break;
 
             // dissolve: replace 'random' rects
         case Okular::PageTransition::Dissolve:
         {
             const int gridXsteps = 50;
             const int gridYsteps = 38;
             const int steps = gridXsteps * gridYsteps;
             int oldX = 0;
             int oldY = 0;
             // create a grid of gridXstep by gridYstep QRects
             for ( int y = 0; y < gridYsteps; y++ )
             {
                 int newY = (int)( m_height * ((float)(y+1) / (float)gridYsteps) );
                 for ( int x = 0; x < gridXsteps; x++ )
                 {
                     int newX = (int)( m_width * ((float)(x+1) / (float)gridXsteps) );
                     m_transitionRects.push_back( QRect( oldX, oldY, newX - oldX, newY - oldY ) );
                     oldX = newX;
                 }
                 oldX = 0;
                 oldY = newY;
             }
             // randomize the grid
             for ( int i = 0; i < steps; i++ )
             {
 #ifndef Q_OS_WIN
                 int n1 = (int)(steps * drand48());
                 int n2 = (int)(steps * drand48());
 #else
                 int n1 = (int)(steps * (std::rand() / RAND_MAX));
                 int n2 = (int)(steps * (std::rand() / RAND_MAX));
 #endif
                 // swap items if index differs
                 if ( n1 != n2 )
                 {
                     QRect r = m_transitionRects[ n2 ];
                     m_transitionRects[ n2 ] = m_transitionRects[ n1 ];
                     m_transitionRects[ n1 ] = r;
                 }
             }
             // set global transition parameters
             m_transitionMul = 40;
             m_transitionDelay = (int)( (m_transitionMul * 1000 * totalTime) / steps );
         } break;
 
             // glitter: similar to dissolve but has a direction
         case Okular::PageTransition::Glitter:
         {
             const int gridXsteps = 50;
             const int gridYsteps = 38;
             const int steps = gridXsteps * gridYsteps;
             const int angle = transition->angle();
             // generate boxes using a given direction
             if ( angle == 90 )
             {
                 int yPosition = m_height;
                 for ( int i = 0; i < gridYsteps; i++ )
                 {
                     int yNext = ((gridYsteps - (i + 1)) * m_height) / gridYsteps;
                     int xPosition = 0;
                     for ( int j = 0; j < gridXsteps; j++ )
                     {
                         int xNext = ((j + 1) * m_width) / gridXsteps;
                         m_transitionRects.push_back( QRect( xPosition, yNext, xNext - xPosition, yPosition - yNext ) );
                         xPosition = xNext;
                     }
                     yPosition = yNext;
                 }
             }
             else if ( angle == 180 )
             {
                 int xPosition = m_width;
                 for ( int i = 0; i < gridXsteps; i++ )
                 {
                     int xNext = ((gridXsteps - (i + 1)) * m_width) / gridXsteps;
                     int yPosition = 0;
                     for ( int j = 0; j < gridYsteps; j++ )
                     {
                         int yNext = ((j + 1) * m_height) / gridYsteps;
                         m_transitionRects.push_back( QRect( xNext, yPosition, xPosition - xNext, yNext - yPosition ) );
                         yPosition = yNext;
                     }
                     xPosition = xNext;
                 }
             }
             else if ( angle == 270 )
             {
                 int yPosition = 0;
                 for ( int i = 0; i < gridYsteps; i++ )
                 {
                     int yNext = ((i + 1) * m_height) / gridYsteps;
                     int xPosition = 0;
                     for ( int j = 0; j < gridXsteps; j++ )
                     {
                         int xNext = ((j + 1) * m_width) / gridXsteps;
                         m_transitionRects.push_back( QRect( xPosition, yPosition, xNext - xPosition, yNext - yPosition ) );
                         xPosition = xNext;
                     }
                     yPosition = yNext;
                 }
             }
             else // if angle is 0 or 315
             {
                 int xPosition = 0;
                 for ( int i = 0; i < gridXsteps; i++ )
                 {
                     int xNext = ((i + 1) * m_width) / gridXsteps;
                     int yPosition = 0;
                     for ( int j = 0; j < gridYsteps; j++ )
                     {
                         int yNext = ((j + 1) * m_height) / gridYsteps;
                         m_transitionRects.push_back( QRect( xPosition, yPosition, xNext - xPosition, yNext - yPosition ) );
                         yPosition = yNext;
                     }
                     xPosition = xNext;
                 }
             }
             // add a 'glitter' (1 over 10 pieces is randomized)
             int randomSteps = steps / 20;
             for ( int i = 0; i < randomSteps; i++ )
             {
 #ifndef Q_OS_WIN
                 int n1 = (int)(steps * drand48());
                 int n2 = (int)(steps * drand48());
 #else
                 int n1 = (int)(steps * (std::rand() / RAND_MAX));
                 int n2 = (int)(steps * (std::rand() / RAND_MAX));
 #endif
                 // swap items if index differs
                 if ( n1 != n2 )
                 {
                     QRect r = m_transitionRects[ n2 ];
                     m_transitionRects[ n2 ] = m_transitionRects[ n1 ];
                     m_transitionRects[ n1 ] = r;
                 }
             }
             // set global transition parameters
             m_transitionMul = (angle == 90) || (angle == 270) ? gridYsteps : gridXsteps;
             m_transitionMul /= 2;
             m_transitionDelay = (int)( (m_transitionMul * 1000 * totalTime) / steps );
         } break;
 
         case Okular::PageTransition::Fade:
         {
             enum {FADE_TRANSITION_FPS = 20};
             const int steps = totalTime * FADE_TRANSITION_FPS;
             m_transitionSteps = steps;
             QPainter pixmapPainter;
             m_currentPixmapOpacity = (double) 1 / steps;
             m_transitionDelay = (int)( totalTime * 1000 ) / steps;
             m_lastRenderedPixmap = QPixmap( m_lastRenderedPixmap.size() );
             m_lastRenderedPixmap.fill( Qt::transparent );
             pixmapPainter.begin( &m_lastRenderedPixmap );
             pixmapPainter.setCompositionMode( QPainter::CompositionMode_Source );
             pixmapPainter.setOpacity( 1 - m_currentPixmapOpacity );
             pixmapPainter.drawPixmap( 0, 0, m_previousPagePixmap );
             pixmapPainter.setOpacity( m_currentPixmapOpacity );
             pixmapPainter.drawPixmap( 0, 0, m_currentPagePixmap );
             pixmapPainter.end();
             update();
         } break;
         // implement missing transitions (a binary raster engine needed here)
         case Okular::PageTransition::Fly:
 
         case Okular::PageTransition::Push:
 
         case Okular::PageTransition::Cover:
 
         case Okular::PageTransition::Uncover:
 
         default:
             update();
             return;
     }
 
     // send the first start to the timer
     m_transitionTimer->start( 0 );
 }
 
 void PresentationWidget::slotProcessMovieAction( const Okular::MovieAction *action )
 {
     const Okular::MovieAnnotation *movieAnnotation = action->annotation();
     if ( !movieAnnotation )
         return;
 
     Okular::Movie *movie = movieAnnotation->movie();
     if ( !movie )
         return;
 
     VideoWidget *vw = m_frames[ m_frameIndex ]->videoWidgets.value( movieAnnotation->movie() );
     if ( !vw )
         return;
 
     vw->show();
 
     switch ( action->operation() )
     {
         case Okular::MovieAction::Play:
             vw->stop();
             vw->play();
             break;
         case Okular::MovieAction::Stop:
             vw->stop();
             break;
         case Okular::MovieAction::Pause:
             vw->pause();
             break;
         case Okular::MovieAction::Resume:
             vw->play();
             break;
     };
 }
 
 void PresentationWidget::slotProcessRenditionAction( const Okular::RenditionAction *action )
 {
     Okular::Movie *movie = action->movie();
     if ( !movie )
         return;
 
     VideoWidget *vw = m_frames[ m_frameIndex ]->videoWidgets.value( movie );
     if ( !vw )
         return;
 
     if ( action->operation() == Okular::RenditionAction::None )
         return;
 
     vw->show();
 
     switch ( action->operation() )
     {
         case Okular::RenditionAction::Play:
             vw->stop();
             vw->play();
             break;
         case Okular::RenditionAction::Stop:
             vw->stop();
             break;
         case Okular::RenditionAction::Pause:
             vw->pause();
             break;
         case Okular::RenditionAction::Resume:
             vw->play();
             break;
         default:
             return;
     };
 }
 
 void PresentationWidget::slotTogglePlayPause()
 {
     m_advanceSlides = !m_advanceSlides;
     setPlayPauseIcon();
     if ( m_advanceSlides )
     {
         startAutoChangeTimer();
     }
     else
     {
         m_nextPageTimer->stop();
     }
 }
 
 #include "presentationwidget.moc"
diff --git a/ui/thumbnaillist.cpp b/ui/thumbnaillist.cpp
index 1be61141a..101b97649 100644
--- a/ui/thumbnaillist.cpp
+++ b/ui/thumbnaillist.cpp
@@ -1,1009 +1,1009 @@
 /***************************************************************************
  *   Copyright (C) 2004-2006 by Albert Astals Cid <aacid@kde.org>          *
  *                                                                         *
  *   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.                                   *
  ***************************************************************************/
 
 #include "thumbnaillist.h"
 
 // qt/kde includes
 #include <QAction>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QIcon>
 #include <QPainter>
 #include <QResizeEvent>
 #include <QScrollBar>
 #include <QSizePolicy>
 #include <QStyle>
 #include <QTimer>
 
 #include <KLocalizedString>
 #include <KIconLoader>
 #include <KActionCollection>
 
 // local includes
 #include "pagepainter.h"
 #include "core/area.h"
 #include "core/bookmarkmanager.h"
 #include "core/document.h"
 #include "core/generator.h"
 #include "core/page.h"
 #include "settings.h"
 #include "priorities.h"
 
 class ThumbnailWidget;
 
 class ThumbnailListPrivate : public QWidget
 {
     public:
         ThumbnailListPrivate( ThumbnailList *qq, Okular::Document *document );
         ~ThumbnailListPrivate() override;
 
         enum ChangePageDirection
         {
             Null,
             Left,
             Right,
             Up,
             Down
         };
 
         ThumbnailList *q;
         Okular::Document *m_document;
         ThumbnailWidget *m_selected;
         QTimer *m_delayTimer;
         QPixmap *m_bookmarkOverlay;
         QVector<ThumbnailWidget *> m_thumbnails;
         QList<ThumbnailWidget *> m_visibleThumbnails;
         int m_vectorIndex;
         // Grabbing variables
         QPoint m_mouseGrabPos;
         ThumbnailWidget *m_mouseGrabItem;
         int m_pageCurrentlyGrabbed;
 
         // resize thumbnails to fit the width
         void viewportResizeEvent( QResizeEvent * );
         // called by ThumbnailWidgets to get the overlay bookmark pixmap
         const QPixmap * getBookmarkOverlay() const;
         // called by ThumbnailWidgets to send (forward) the mouse move signals
         ChangePageDirection forwardTrack( const QPoint &, const QSize & );
 
         ThumbnailWidget* itemFor( const QPoint & p ) const;
         void delayedRequestVisiblePixmaps( int delayMs = 0 );
 
         // SLOTS:
         // make requests for generating pixmaps for visible thumbnails
         void slotRequestVisiblePixmaps( int newContentsY = -1 );
         // delay timeout: resize overlays and requests pixmaps
         void slotDelayTimeout();
         ThumbnailWidget* getPageByNumber( int page ) const;
         int getNewPageOffset( int n, ThumbnailListPrivate::ChangePageDirection dir ) const;
         ThumbnailWidget *getThumbnailbyOffset( int current, int offset ) const;
 
     protected:
         void mousePressEvent( QMouseEvent * e ) override;
         void mouseReleaseEvent( QMouseEvent * e ) override;
         void mouseMoveEvent( QMouseEvent * e ) override;
         void wheelEvent( QWheelEvent * e ) override;
         void contextMenuEvent( QContextMenuEvent * e ) override;
         void paintEvent( QPaintEvent * e ) override;
 };
 
 
 // ThumbnailWidget represents a single thumbnail in the ThumbnailList
 class ThumbnailWidget
 {
     public:
         ThumbnailWidget( ThumbnailListPrivate * parent, const Okular::Page * page );
 
         // set internal parameters to fit the page in the given width
         void resizeFitWidth( int width );
         // set thumbnail's selected state
         void setSelected( bool selected );
         // set the visible rect of the current page
         void setVisibleRect( const Okular::NormalizedRect & rect );
 
         // query methods
         int heightHint() const { return m_pixmapHeight + m_labelHeight + m_margin; }
         int pixmapWidth() const { return m_pixmapWidth; }
         int pixmapHeight() const { return m_pixmapHeight; }
         int pageNumber() const { return m_page->number(); }
         const Okular::Page * page() const { return m_page; }
         QRect visibleRect() const { return m_visibleRect.geometry( m_pixmapWidth, m_pixmapHeight ); }
 
         void paint( QPainter &p, const QRect &clipRect );
 
         static int margin() { return m_margin; }
 
         // simulating QWidget
         QRect rect() const { return m_rect; }
         int height() const { return m_rect.height(); }
         int width() const { return m_rect.width(); }
         QPoint pos() const { return m_rect.topLeft(); }
         void move( int x, int y ) { m_rect.setTopLeft( QPoint( x, y ) ); }
         void update() { m_parent->update( m_rect ); }
         void update( const QRect & rect ) { m_parent->update( rect.translated( m_rect.topLeft() ) ); }
 
     private:
         // the margin around the widget
         static int const m_margin = 16;
 
         ThumbnailListPrivate * m_parent;
         const Okular::Page * m_page;
         bool m_selected;
         int m_pixmapWidth, m_pixmapHeight;
         int m_labelHeight, m_labelNumber;
         Okular::NormalizedRect m_visibleRect;
         QRect m_rect;
 };
 
 
 ThumbnailListPrivate::ThumbnailListPrivate( ThumbnailList *qq, Okular::Document *document )
     : QWidget(), q( qq ), m_document( document ), m_selected( 0 ),
     m_delayTimer( 0 ), m_bookmarkOverlay( 0 ), m_vectorIndex( 0 )
 {
     setMouseTracking( true );
     m_mouseGrabItem = 0;
 }
 
 
 ThumbnailWidget* ThumbnailListPrivate::getPageByNumber( int page ) const
 {
     QVector< ThumbnailWidget * >::const_iterator tIt = m_thumbnails.constBegin(), tEnd = m_thumbnails.constEnd();
     for ( ; tIt != tEnd; ++tIt )
     {
         if ( (*tIt)->pageNumber() == page )
             return (*tIt);
     }
     return 0;
 }
 
 ThumbnailListPrivate::~ThumbnailListPrivate()
 {
 }
 
 ThumbnailWidget* ThumbnailListPrivate::itemFor( const QPoint & p ) const
 {
     QVector< ThumbnailWidget * >::const_iterator tIt = m_thumbnails.constBegin(), tEnd = m_thumbnails.constEnd();
     for ( ; tIt != tEnd; ++tIt )
     {
         if ( (*tIt)->rect().contains( p ) )
             return (*tIt);
     }
     return 0;
 }
 
 void ThumbnailListPrivate::paintEvent( QPaintEvent * e )
 {
     QPainter painter( this );
     QVector<ThumbnailWidget *>::const_iterator tIt = m_thumbnails.constBegin(), tEnd = m_thumbnails.constEnd();
     for ( ; tIt != tEnd; ++tIt )
     {
         QRect rect = e->rect().intersected( (*tIt)->rect() );
         if ( !rect.isNull() )
         {
             rect.translate( -(*tIt)->pos() );
             painter.save();
             painter.translate( (*tIt)->pos() );
             (*tIt)->paint( painter, rect );
             painter.restore();
         }
     }
 }
 
 
 /** ThumbnailList implementation **/
 
 ThumbnailList::ThumbnailList( QWidget *parent, Okular::Document *document )
     : QScrollArea( parent ), d( new ThumbnailListPrivate( this, document ) )
 {
     setObjectName( QStringLiteral( "okular::Thumbnails" ) );
     // set scrollbars
     setHorizontalScrollBarPolicy( Qt::ScrollBarAlwaysOff );
     setVerticalScrollBarPolicy( Qt::ScrollBarAlwaysOn );
     verticalScrollBar()->setEnabled( false );
 
     setAttribute( Qt::WA_StaticContents );
 
     viewport()->setBackgroundRole( QPalette::Base );
 
     setWidget( d );
     // widget setup: can be focused by mouse click (not wheel nor tab)
     widget()->setFocusPolicy( Qt::ClickFocus );
     widget()->show();
     widget()->setBackgroundRole( QPalette::Base );
 
     connect( verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRequestVisiblePixmaps(int)) );
 }
 
 ThumbnailList::~ThumbnailList()
 {
     d->m_document->removeObserver( this );
     delete d->m_bookmarkOverlay;
 }
 
 //BEGIN DocumentObserver inherited methods
 void ThumbnailList::notifySetup( const QVector< Okular::Page * > & pages, int setupFlags )
 {
     // if there was a widget selected, save its pagenumber to restore
     // its selection (if available in the new set of pages)
     int prevPage = -1;
     if ( !( setupFlags & Okular::DocumentObserver::DocumentChanged ) && d->m_selected )
     {
         prevPage = d->m_selected->page()->number();
     } else
         prevPage = d->m_document->viewport().pageNumber;
 
     // delete all the Thumbnails
     QVector<ThumbnailWidget *>::const_iterator tIt = d->m_thumbnails.constBegin(), tEnd = d->m_thumbnails.constEnd();
     for ( ; tIt != tEnd; ++tIt )
         delete *tIt;
     d->m_thumbnails.clear();
     d->m_visibleThumbnails.clear();
     d->m_selected = 0;
     d->m_mouseGrabItem = 0;
 
     if ( pages.count() < 1 )
     {
         widget()->resize( 0, 0 );
         return;
     }
 
     // show pages containing hilighted text or bookmarked ones
     //RESTORE THIS int flags = Okular::Settings::filterBookmarks() ? Okular::Page::Bookmark : Okular::Page::Highlight;
 
     // if no page matches filter rule, then display all pages
     QVector< Okular::Page * >::const_iterator pIt = pages.constBegin(), pEnd = pages.constEnd();
     bool skipCheck = true;
     for ( ; pIt != pEnd ; ++pIt )
         //if ( (*pIt)->attributes() & flags )
         if ( (*pIt)->hasHighlights( SW_SEARCH_ID ) )
             skipCheck = false;
 
     // generate Thumbnails for the given set of pages
     const int width = viewport()->width();
     int height = 0;
     int centerHeight = 0;
     for ( pIt = pages.constBegin(); pIt != pEnd ; ++pIt )
         //if ( skipCheck || (*pIt)->attributes() & flags )
         if ( skipCheck || (*pIt)->hasHighlights( SW_SEARCH_ID ) )
         {
             ThumbnailWidget * t = new ThumbnailWidget( d, *pIt );
             t->move(0, height);
             // add to the internal queue
             d->m_thumbnails.push_back( t );
             // update total height (asking widget its own height)
             t->resizeFitWidth( width );
             // restoring the previous selected page, if any
             if ( (*pIt)->number() < prevPage )
             {
                 centerHeight = height + t->height() + this->style()->layoutSpacing(QSizePolicy::Frame, QSizePolicy::Frame, Qt::Vertical)/2;
             }
             if ( (*pIt)->number() == prevPage )
             {
                 d->m_selected = t;
                 d->m_selected->setSelected( true );
                 centerHeight = height + t->height() / 2;
             }
             height += t->height() + this->style()->layoutSpacing(QSizePolicy::Frame, QSizePolicy::Frame, Qt::Vertical);
         }
 
     // update scrollview's contents size (sets scrollbars limits)
     height -= this->style()->layoutSpacing(QSizePolicy::Frame, QSizePolicy::Frame, Qt::Vertical);
     widget()->resize( width, height );
 
     // enable scrollbar when there's something to scroll
     verticalScrollBar()->setEnabled( viewport()->height() < height );
     verticalScrollBar()->setValue(centerHeight - viewport()->height() / 2);
 
     // request for thumbnail generation
     d->delayedRequestVisiblePixmaps( 200 );
 }
 
 void ThumbnailList::notifyCurrentPageChanged( int previousPage, int currentPage )
 {
     Q_UNUSED( previousPage )
 
     // skip notifies for the current page (already selected)
     if ( d->m_selected && d->m_selected->pageNumber() == currentPage )
         return;
 
     // deselect previous thumbnail
     if ( d->m_selected )
         d->m_selected->setSelected( false );
     d->m_selected = 0;
 
     // select the page with viewport and ensure it's centered in the view
     d->m_vectorIndex = 0;
     QVector<ThumbnailWidget *>::const_iterator tIt = d->m_thumbnails.constBegin(), tEnd = d->m_thumbnails.constEnd();
     for ( ; tIt != tEnd; ++tIt )
     {
         if ( (*tIt)->pageNumber() == currentPage )
         {
             d->m_selected = *tIt;
             d->m_selected->setSelected( true );
             if ( Okular::Settings::syncThumbnailsViewport() )
             {
                 int yOffset = qMax( viewport()->height() / 4, d->m_selected->height() / 2 );
                 ensureVisible( 0, d->m_selected->pos().y() + d->m_selected->height()/2, 0, yOffset );
             }
             break;
         }
         d->m_vectorIndex++;
     }
 }
 
 void ThumbnailList::notifyPageChanged( int pageNumber, int changedFlags )
 {
     static const int interestingFlags = DocumentObserver::Pixmap | DocumentObserver::Bookmark | DocumentObserver::Highlights | DocumentObserver::Annotations;
     // only handle change notifications we are interested in
     if ( !( changedFlags & interestingFlags ) )
         return;
 
     // iterate over visible items: if page(pageNumber) is one of them, repaint it
     QList<ThumbnailWidget *>::const_iterator vIt = d->m_visibleThumbnails.constBegin(), vEnd = d->m_visibleThumbnails.constEnd();
     for ( ; vIt != vEnd; ++vIt )
         if ( (*vIt)->pageNumber() == pageNumber )
         {
             (*vIt)->update();
             break;
         }
 }
 
 void ThumbnailList::notifyContentsCleared( int changedFlags )
 {
     // if pixmaps were cleared, re-ask them
     if ( changedFlags & DocumentObserver::Pixmap )
         d->slotRequestVisiblePixmaps();
 }
 
 void ThumbnailList::notifyVisibleRectsChanged()
 {
     bool found = false;
     const QVector<Okular::VisiblePageRect *> & visibleRects = d->m_document->visiblePageRects();
     QVector<ThumbnailWidget *>::const_iterator tIt = d->m_thumbnails.constBegin(), tEnd = d->m_thumbnails.constEnd();
     QVector<Okular::VisiblePageRect *>::const_iterator vEnd = visibleRects.end();
     for ( ; tIt != tEnd; ++tIt )
     {
         found = false;
         QVector<Okular::VisiblePageRect *>::const_iterator vIt = visibleRects.begin();
         for ( ; ( vIt != vEnd ) && !found; ++vIt )
         {
             if ( (*tIt)->pageNumber() == (*vIt)->pageNumber )
             {
                 (*tIt)->setVisibleRect( (*vIt)->rect );
                 found = true;
             }
         }
         if ( !found )
         {
             (*tIt)->setVisibleRect( Okular::NormalizedRect() );
         }
     }
 }
 
 bool ThumbnailList::canUnloadPixmap( int pageNumber ) const
 {
     // if the thubnail 'pageNumber' is one of the visible ones, forbid unloading
     QList<ThumbnailWidget *>::const_iterator vIt = d->m_visibleThumbnails.constBegin(), vEnd = d->m_visibleThumbnails.constEnd();
     for ( ; vIt != vEnd; ++vIt )
         if ( (*vIt)->pageNumber() == pageNumber )
             return false;
     // if hidden permit unloading
     return true;
 }
 //END DocumentObserver inherited methods
 
 
 void ThumbnailList::updateWidgets()
 {
     // Update all visible widgets
     QList<ThumbnailWidget *>::const_iterator vIt = d->m_visibleThumbnails.constBegin(), vEnd = d->m_visibleThumbnails.constEnd();
     for ( ; vIt != vEnd; ++vIt )
     {
         ThumbnailWidget * t = *vIt;
         t->update();
     }
 }
 
 int ThumbnailListPrivate::getNewPageOffset(int n, ThumbnailListPrivate::ChangePageDirection dir) const
 {
     int reason = 1;
     int facingFirst = 0; //facingFirstCentered cornercase
     if ( Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Facing )
         reason = 2;
     else if (Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::FacingFirstCentered )
     {
         facingFirst = 1;
         reason = 2;
     }
     else if ( Okular::Settings::viewMode() == Okular::Settings::EnumViewMode::Summary )
         reason = 3;
     if ( dir == ThumbnailListPrivate::Up )
     {
         if ( facingFirst && n == 1 )
             return -1;
         return -reason;
     }
     if ( dir == ThumbnailListPrivate::Down )
         return reason;
     if ( dir == ThumbnailListPrivate::Left && reason > 1 && (n + facingFirst)  % reason )
         return -1;
     if ( dir == ThumbnailListPrivate::Right && reason > 1 && (n + 1 + facingFirst) % reason )
         return 1;
     return 0;
 }
 
 ThumbnailWidget *ThumbnailListPrivate::getThumbnailbyOffset(int current, int offset) const
 {
     QVector<ThumbnailWidget *>::const_iterator it = m_thumbnails.begin();
     QVector<ThumbnailWidget *>::const_iterator itE = m_thumbnails.end();
     int idx = 0;
     while ( it != itE )
     {
         if ( (*it)->pageNumber() == current )
             break;
         ++idx;
         ++it;
     }
     if ( it == itE )
         return 0;
     idx += offset;
     if ( idx < 0 || idx >= m_thumbnails.size() )
         return 0;
     return m_thumbnails[idx];
 }
 
 ThumbnailListPrivate::ChangePageDirection ThumbnailListPrivate::forwardTrack(const QPoint &point, const QSize &r )
 {
     Okular::DocumentViewport vp = m_document->viewport();
     const double deltaX = (double)point.x() / r.width(),
                  deltaY = (double)point.y() / r.height();
     vp.rePos.normalizedX -= deltaX;
     vp.rePos.normalizedY -= deltaY;
     if ( vp.rePos.normalizedY > 1.0 )
         return ThumbnailListPrivate::Down;
     if ( vp.rePos.normalizedY < 0.0 )
         return ThumbnailListPrivate::Up;
     if ( vp.rePos.normalizedX > 1.0 )
         return ThumbnailListPrivate::Right;
     if ( vp.rePos.normalizedX < 0.0 )
         return ThumbnailListPrivate::Left;
     vp.rePos.enabled = true;
     m_document->setViewport( vp );
     return ThumbnailListPrivate::Null;
 }
 
 const QPixmap * ThumbnailListPrivate::getBookmarkOverlay() const
 {
     return m_bookmarkOverlay;
 }
 
 void ThumbnailList::slotFilterBookmarks( bool filterOn )
 {
     // save state
     Okular::Settings::setFilterBookmarks( filterOn );
     Okular::Settings::self()->save();
     // ask for the 'notifySetup' with a little trick (on reinsertion the
     // document sends the list again)
     d->m_document->removeObserver( this );
     d->m_document->addObserver( this );
 }
 
 
 //BEGIN widget events
 void ThumbnailList::keyPressEvent( QKeyEvent * keyEvent )
 {
     if ( d->m_thumbnails.count() < 1 )
         return keyEvent->ignore();
 
     int nextPage = -1;
     if ( keyEvent->key() == Qt::Key_Up )
     {
         if ( !d->m_selected )
             nextPage = 0;
         else if ( d->m_vectorIndex > 0 )
             nextPage = d->m_thumbnails[ d->m_vectorIndex - 1 ]->pageNumber();
     }
     else if ( keyEvent->key() == Qt::Key_Down )
     {
         if ( !d->m_selected )
             nextPage = 0;
         else if ( d->m_vectorIndex < (int)d->m_thumbnails.count() - 1 )
             nextPage = d->m_thumbnails[ d->m_vectorIndex + 1 ]->pageNumber();
     }
     else if ( keyEvent->key() == Qt::Key_PageUp )
         verticalScrollBar()->triggerAction( QScrollBar::SliderPageStepSub );
     else if ( keyEvent->key() == Qt::Key_PageDown )
         verticalScrollBar()->triggerAction( QScrollBar::SliderPageStepAdd );
     else if ( keyEvent->key() == Qt::Key_Home )
         nextPage = d->m_thumbnails[ 0 ]->pageNumber();
     else if ( keyEvent->key() == Qt::Key_End )
         nextPage = d->m_thumbnails[ d->m_thumbnails.count() - 1 ]->pageNumber();
 
     if ( nextPage == -1 )
         return keyEvent->ignore();
 
     keyEvent->accept();
     if ( d->m_selected )
         d->m_selected->setSelected( false );
     d->m_selected = 0;
     d->m_document->setViewportPage( nextPage );
 }
 
 bool ThumbnailList::viewportEvent( QEvent * e )
 {
     switch ( e->type() )
     {
         case QEvent::Resize:
         {
             d->viewportResizeEvent( (QResizeEvent*)e );
             break;
         }
         default:
             ;
     }
     return QScrollArea::viewportEvent( e );
 }
 
 void ThumbnailListPrivate::viewportResizeEvent( QResizeEvent * e )
 {
     if ( m_thumbnails.count() < 1 || width() < 1 )
         return;
 
     // if width changed resize all the Thumbnails, reposition them to the
     // right place and recalculate the contents area
     if ( e->size().width() != e->oldSize().width() )
     {
         // runs the timer avoiding a thumbnail regeneration by 'contentsMoving'
         delayedRequestVisiblePixmaps( 2000 );
 
         // resize and reposition items
         const int newWidth = q->viewport()->width();
         int newHeight = 0;
         QVector<ThumbnailWidget *>::const_iterator tIt = m_thumbnails.constBegin(), tEnd = m_thumbnails.constEnd();
         for ( ; tIt != tEnd; ++tIt )
         {
             ThumbnailWidget *t = *tIt;
             t->move(0, newHeight);
             t->resizeFitWidth( newWidth );
             newHeight += t->height() + this->style()->layoutSpacing(QSizePolicy::Frame, QSizePolicy::Frame, Qt::Vertical);
         }
 
         // update scrollview's contents size (sets scrollbars limits)
         newHeight -= this->style()->layoutSpacing(QSizePolicy::Frame, QSizePolicy::Frame, Qt::Vertical);
         const int oldHeight = q->widget()->height();
         const int oldYCenter = q->verticalScrollBar()->value() + q->viewport()->height() / 2;
         q->widget()->resize( newWidth, newHeight );
 
         // enable scrollbar when there's something to scroll
         q->verticalScrollBar()->setEnabled( q->viewport()->height() < newHeight );
 
         // ensure that what was visibile before remains visible now
         q->ensureVisible( 0, int( (qreal)oldYCenter * q->widget()->height() / oldHeight ), 0, q->viewport()->height() / 2 );
     }
     else if ( e->size().height() <= e->oldSize().height() )
         return;
 
     // invalidate the bookmark overlay
     if ( m_bookmarkOverlay )
     {
         delete m_bookmarkOverlay;
         m_bookmarkOverlay = 0;
     }
 
     // update Thumbnails since width has changed or height has increased
     delayedRequestVisiblePixmaps( 500 );
 }
 //END widget events
 
 //BEGIN internal SLOTS
 void ThumbnailListPrivate::slotRequestVisiblePixmaps( int /*newContentsY*/ )
 {
     // if an update is already scheduled or the widget is hidden, don't proceed
     if ( ( m_delayTimer && m_delayTimer->isActive() ) || q->isHidden() )
         return;
 
     // scroll from the top to the last visible thumbnail
     m_visibleThumbnails.clear();
     QLinkedList< Okular::PixmapRequest * > requestedPixmaps;
     QVector<ThumbnailWidget *>::const_iterator tIt = m_thumbnails.constBegin(), tEnd = m_thumbnails.constEnd();
     const QRect viewportRect = q->viewport()->rect().translated( q->horizontalScrollBar()->value(), q->verticalScrollBar()->value() );
     for ( ; tIt != tEnd; ++tIt )
     {
         ThumbnailWidget * t = *tIt;
         const QRect thumbRect = t->rect();
         if ( !thumbRect.intersects( viewportRect ) )
           continue;
         // add ThumbnailWidget to visible list
         m_visibleThumbnails.push_back( t );
         // if pixmap not present add it to requests
         if ( !t->page()->hasPixmap( q, t->pixmapWidth(), t->pixmapHeight() ) )
         {
-            Okular::PixmapRequest * p = new Okular::PixmapRequest( q, t->pageNumber(), t->pixmapWidth(), t->pixmapHeight(), devicePixelRatioF(), THUMBNAILS_PRIO, Okular::PixmapRequest::Asynchronous );
+            Okular::PixmapRequest * p = new Okular::PixmapRequest( q, t->pageNumber(), t->pixmapWidth(), t->pixmapHeight(), THUMBNAILS_PRIO, Okular::PixmapRequest::Asynchronous );
             requestedPixmaps.push_back( p );
         }
     }
 
     // actually request pixmaps
     if ( !requestedPixmaps.isEmpty() )
         m_document->requestPixmaps( requestedPixmaps );
 }
 
 void ThumbnailListPrivate::slotDelayTimeout()
 {
     // resize the bookmark overlay
     delete m_bookmarkOverlay;
     const int expectedWidth = q->viewport()->width() / 4;
     if ( expectedWidth > 10 )
         m_bookmarkOverlay = new QPixmap( DesktopIcon( QStringLiteral("bookmarks"), expectedWidth ) );
     else
         m_bookmarkOverlay = 0;
 
     // request pixmaps
     slotRequestVisiblePixmaps();
 }
 //END internal SLOTS
 
 void ThumbnailListPrivate::delayedRequestVisiblePixmaps( int delayMs )
 {
     if ( !m_delayTimer )
     {
         m_delayTimer = new QTimer( q );
         m_delayTimer->setSingleShot( true );
         connect( m_delayTimer, SIGNAL(timeout()), q, SLOT(slotDelayTimeout()) );
     }
     m_delayTimer->start( delayMs );
 }
 
 
 /** ThumbnailWidget implementation **/
 
 ThumbnailWidget::ThumbnailWidget( ThumbnailListPrivate * parent, const Okular::Page * kp )
     : m_parent( parent ), m_page( kp ),
     m_selected( false ), m_pixmapWidth( 10 ), m_pixmapHeight( 10 )
 {
     m_labelNumber = m_page->number() + 1;
     m_labelHeight = QFontMetrics( m_parent->font() ).height();
 
 }
 
 void ThumbnailWidget::resizeFitWidth( int width )
 {
     m_pixmapWidth = width - m_margin;
     m_pixmapHeight = qRound( m_page->ratio() * (double)m_pixmapWidth );
     m_rect.setSize( QSize( width, heightHint() ) );
 }
 
 void ThumbnailWidget::setSelected( bool selected )
 {
     // update selected state
     if ( m_selected != selected )
     {
         m_selected = selected;
         update();
     }
 }
 
 void ThumbnailWidget::setVisibleRect( const Okular::NormalizedRect & rect )
 {
     if ( rect == m_visibleRect )
        return;
 
     m_visibleRect = rect;
     update();
 }
 
 void ThumbnailListPrivate::mousePressEvent( QMouseEvent * e )
 {
     ThumbnailWidget* item = itemFor( e->pos() );
     if ( !item ) // mouse on the spacing between items
         return e->ignore();
 
     const QRect r = item->visibleRect();
     const int margin = ThumbnailWidget::margin();
     const QPoint p = e->pos() - item->pos();
 
     if ( e->button() != Qt::RightButton && r.contains( p - QPoint( margin / 2, margin / 2 ) ) )
     {
         m_mouseGrabPos.setX( 0 );
         m_mouseGrabPos.setY( 0 );
         m_mouseGrabItem = item;
         m_pageCurrentlyGrabbed = item->pageNumber();
         m_mouseGrabItem = item;
     }
     else
     {
         m_mouseGrabPos.setX( 0 );
         m_mouseGrabPos.setY( 0 );
         m_mouseGrabItem = 0;
     }
 }
 
 void ThumbnailListPrivate::mouseReleaseEvent( QMouseEvent * e )
 {
     ThumbnailWidget* item = itemFor( e->pos() );
     m_mouseGrabItem = item;
     if ( !item ) // mouse on the spacing between items
         return e->ignore();
 
     QRect r = item->visibleRect();
     const QPoint p = e->pos() - item->pos();
 
     // jump center of viewport to cursor if it wasn't dragged
     if ( m_mouseGrabPos.isNull() )
     {
         r = item->visibleRect();
         Okular::DocumentViewport vp = Okular::DocumentViewport( item->pageNumber() );
         vp.rePos.normalizedX = double(p.x()) / double(item->rect().width());
         vp.rePos.normalizedY = double(p.y()) / double(item->rect().height());
         vp.rePos.pos = Okular::DocumentViewport::Center;
         vp.rePos.enabled = true;
         m_document->setViewport( vp );
     }
     setCursor( Qt::OpenHandCursor );
     m_mouseGrabPos.setX( 0 );
     m_mouseGrabPos.setY( 0 );
 }
 
 void ThumbnailListPrivate::mouseMoveEvent( QMouseEvent * e )
 {
     if ( e->buttons() == Qt::NoButton )
     {
         ThumbnailWidget* item = itemFor( e->pos() );
         if ( !item ) // mouse on the spacing between items
             return e->ignore();
 
         QRect r = item->visibleRect();
         const int margin = ThumbnailWidget::margin();
         const QPoint p = e->pos() - item->pos();
         if ( r.contains( p - QPoint( margin / 2, margin / 2 ) ) )
         {
             setCursor( Qt::OpenHandCursor );
         }
         else
         {
             setCursor( Qt::ArrowCursor );
         }
 
         return e->ignore();
     }
     // no item under the mouse or previously selected
     if ( !m_mouseGrabItem )
         return e->ignore();
     const QRect r = m_mouseGrabItem->rect();
     if ( !m_mouseGrabPos.isNull() )
     {
         const QPoint mousePos = e->pos();
         const QPoint delta = m_mouseGrabPos - mousePos;
         m_mouseGrabPos = e->pos();
         // don't handle the mouse move, forward it to the thumbnail list
         ThumbnailListPrivate::ChangePageDirection direction;
         if (( direction = forwardTrack( delta, r.size() ))
             != ThumbnailListPrivate::Null )
         {
             // Changing the selected page
             const int offset = getNewPageOffset( m_pageCurrentlyGrabbed, direction );
             const ThumbnailWidget *newThumb = getThumbnailbyOffset( m_pageCurrentlyGrabbed, offset );
             if ( !newThumb )
                 return;
             int newPageOn = newThumb->pageNumber();
             if ( newPageOn == m_pageCurrentlyGrabbed || newPageOn < 0 ||
                  newPageOn >= (int)m_document->pages() )
             {
                 return;
             }
             Okular::DocumentViewport vp = m_document->viewport();
             const float origNormalX = vp.rePos.normalizedX;
             const float origNormalY = vp.rePos.normalizedY;
             vp = Okular::DocumentViewport( newPageOn );
             vp.rePos.normalizedX = origNormalX;
             vp.rePos.normalizedY = origNormalY;
             if ( direction == ThumbnailListPrivate::Up )
             {
                 vp.rePos.normalizedY = 1.0;
                 if ( Okular::Settings::viewMode() ==
                     Okular::Settings::EnumViewMode::FacingFirstCentered
                     && !newPageOn)
                 {
                     if ( m_pageCurrentlyGrabbed == 1 )
                         vp.rePos.normalizedX = origNormalX - 0.5;
                     else
                         vp.rePos.normalizedX = origNormalX + 0.5;
                     if ( vp.rePos.normalizedX < 0.0 )
                         vp.rePos.normalizedX = 0.0;
                     else if ( vp.rePos.normalizedX > 1.0 )
                         vp.rePos.normalizedX = 1.0;
                 }
             }
             else if ( direction == ThumbnailListPrivate::Down )
             {
                 vp.rePos.normalizedY = 0.0;
                 if ( Okular::Settings::viewMode() ==
                      Okular::Settings::EnumViewMode::FacingFirstCentered
                      && !m_pageCurrentlyGrabbed)
                 {
                     if ( origNormalX < 0.5 )
                     {
                         vp = Okular::DocumentViewport( --newPageOn );
                         vp.rePos.normalizedX = origNormalX + 0.5;
                     }
                     else
                         vp.rePos.normalizedX = origNormalX - 0.5;
                     if ( vp.rePos.normalizedX < 0.0 )
                         vp.rePos.normalizedX = 0.0;
                     else if ( vp.rePos.normalizedX > 1.0 )
                         vp.rePos.normalizedX = 1.0;
                 }
             }
             else if ( Okular::Settings::viewMode() != Okular::Settings::EnumViewMode::Single )
             {
                 if ( direction == ThumbnailListPrivate::Left )
                     vp.rePos.normalizedX = 1.0;
                 else
                     vp.rePos.normalizedX = 0.0;
             }
             vp.rePos.pos = Okular::DocumentViewport::Center;
             vp.rePos.enabled = true;
             m_document->setViewport( vp );
             m_mouseGrabPos.setX( 0 );
             m_mouseGrabPos.setY( 0 );
             m_pageCurrentlyGrabbed = newPageOn;
             m_mouseGrabItem = getPageByNumber( m_pageCurrentlyGrabbed );
         }
         // wrap mouse from top to bottom
         const QRect mouseContainer = QApplication::desktop()->screenGeometry( this );
         QPoint currentMousePos = QCursor::pos();
         if ( currentMousePos.y() <= mouseContainer.top() + 4 )
         {
             currentMousePos.setY( mouseContainer.bottom() - 5 );
             QCursor::setPos( currentMousePos );
             m_mouseGrabPos.setX( 0 );
             m_mouseGrabPos.setY( 0 );
         }
         // wrap mouse from bottom to top
         else if ( currentMousePos.y() >= mouseContainer.bottom() - 4 )
         {
             currentMousePos.setY( mouseContainer.top() + 5 );
             QCursor::setPos( currentMousePos );
             m_mouseGrabPos.setX( 0 );
             m_mouseGrabPos.setY( 0 );
         }
     }
     else
     {
         setCursor( Qt::ClosedHandCursor );
         m_mouseGrabPos = e->pos();
     }
 }
 
 void ThumbnailListPrivate::wheelEvent( QWheelEvent * e )
 {
     const ThumbnailWidget* item = itemFor( e->pos() );
     if ( !item ) // wheeling on the spacing between items
         return e->ignore();
 
     const QRect r = item->visibleRect();
     const int margin = ThumbnailWidget::margin();
 
     if ( r.contains( e->pos() - QPoint( margin / 2, margin / 2 ) ) && e->orientation() == Qt::Vertical && e->modifiers() == Qt::ControlModifier )
     {
         m_document->setZoom( e->delta() );
     }
     else
     {
         e->ignore();
     }
 }
 
 void ThumbnailListPrivate::contextMenuEvent( QContextMenuEvent * e )
 {
     const ThumbnailWidget* item = itemFor( e->pos() );
     if ( item )
     {
         emit q->rightClick( item->page(), e->globalPos() );
     }
 }
 
 void ThumbnailWidget::paint( QPainter &p, const QRect &_clipRect )
 {
     const int width = m_pixmapWidth + m_margin;
     QRect clipRect = _clipRect;
     const QPalette pal = m_parent->palette();
 
     // draw the bottom label + highlight mark
     const QColor fillColor = m_selected ? pal.color( QPalette::Active, QPalette::Highlight ) : pal.color( QPalette::Active, QPalette::Base );
     p.fillRect( clipRect, fillColor );
     p.setPen( m_selected ? pal.color( QPalette::Active, QPalette::HighlightedText ) : pal.color( QPalette::Active, QPalette::Text ) );
     p.drawText( 0, m_pixmapHeight + (m_margin - 3), width, m_labelHeight, Qt::AlignCenter, QString::number( m_labelNumber ) );
 
     // draw page outline and pixmap
     if ( clipRect.top() < m_pixmapHeight + m_margin )
     {
         // if page is bookmarked draw a colored border
         const bool isBookmarked = m_parent->m_document->bookmarkManager()->isBookmarked( pageNumber() );
         // draw the inner rect
         p.setPen( isBookmarked ? QColor( 0xFF8000 ) : Qt::black );
         p.drawRect( m_margin/2 - 1, m_margin/2 - 1, m_pixmapWidth + 1, m_pixmapHeight + 1 );
         // draw the clear rect
         p.setPen( isBookmarked ? QColor( 0x804000 ) : pal.color( QPalette::Active, QPalette::Base ) );
         // draw the bottom and right shadow edges
         if ( !isBookmarked )
         {
             int left, right, bottom, top;
             left = m_margin/2 + 1;
             right = m_margin/2 + m_pixmapWidth + 1;
             bottom = m_pixmapHeight + m_margin/2 + 1;
             top = m_margin/2 + 1;
             p.setPen( Qt::gray );
             p.drawLine( left, bottom, right, bottom );
             p.drawLine( right, top, right, bottom );
         }
 
         // draw the page using the shared PagePainter class
         p.translate( m_margin/2, m_margin/2 );
         clipRect.translate( -m_margin/2, -m_margin/2 );
         clipRect = clipRect.intersected( QRect( 0, 0, m_pixmapWidth, m_pixmapHeight ) );
         if ( clipRect.isValid() )
         {
             int flags = PagePainter::Accessibility | PagePainter::Highlights |
                         PagePainter::Annotations;
             PagePainter::paintPageOnPainter( &p, m_page, m_parent->q, flags, m_pixmapWidth, m_pixmapHeight, clipRect );
         }
 
         if ( !m_visibleRect.isNull() )
         {
             p.save();
             p.setPen( QColor( 255, 255, 0, 200 ) );
             p.setBrush( QColor( 0, 0, 0, 100 ) );
             p.drawRect( m_visibleRect.geometry( m_pixmapWidth, m_pixmapHeight ).adjusted( 0, 0, -1, -1 ) );
             p.restore();
         }
 
         // draw the bookmark overlay on the top-right corner
         const QPixmap * bookmarkPixmap = m_parent->getBookmarkOverlay();
         if ( isBookmarked && bookmarkPixmap )
         {
             int pixW = bookmarkPixmap->width(),
                 pixH = bookmarkPixmap->height();
             clipRect = clipRect.intersected( QRect( m_pixmapWidth - pixW, 0, pixW, pixH ) );
             if ( clipRect.isValid() )
                 p.drawPixmap( m_pixmapWidth - pixW, -pixH/8, *bookmarkPixmap );
         }
     }
 }
 
 
 /** ThumbnailsController implementation **/
 
 #define FILTERB_ID  1
 
 ThumbnailController::ThumbnailController( QWidget * parent, ThumbnailList * list )
     : QToolBar( parent )
 {
     setObjectName( QStringLiteral( "ThumbsControlBar" ) );
     // change toolbar appearance
     setIconSize( QSize( 16, 16 ) );
     setMovable( false );
     QSizePolicy sp = sizePolicy();
     sp.setVerticalPolicy( QSizePolicy::Minimum );
     setSizePolicy( sp );
 
     // insert a togglebutton [show only bookmarked pages]
     //insertSeparator();
     QAction * showBoomarkOnlyAction = addAction(
         QIcon::fromTheme( QStringLiteral("bookmarks") ), i18n( "Show bookmarked pages only" ) );
     showBoomarkOnlyAction->setCheckable( true );
     connect( showBoomarkOnlyAction, &QAction::toggled, list, &ThumbnailList::slotFilterBookmarks );
     showBoomarkOnlyAction->setChecked( Okular::Settings::filterBookmarks() );
     //insertLineSeparator();
 }
 
 
 #include "moc_thumbnaillist.cpp"
 
 /* kate: replace-tabs on; indent-width 4; */