diff --git a/core/document.cpp b/core/document.cpp
index 2286a936e..145979fd7 100644
--- a/core/document.cpp
+++ b/core/document.cpp
@@ -1,5195 +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() );
             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();
-        PixmapRequest * p = new PixmapRequest( it.key(), pageNumber, ceil( size.width() / qApp->devicePixelRatio() ), ceil( size.height() / qApp->devicePixelRatio() ), 1, PixmapRequest::Asynchronous );
+        PixmapRequest * p = new PixmapRequest( it.key(), pageNumber, size.width() / qApp->devicePixelRatio(), size.height() / qApp->devicePixelRatio(), 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, ceil( tilesManager->width() / qApp->devicePixelRatio() ), ceil( tilesManager->height() / qApp->devicePixelRatio() ), 1, PixmapRequest::Asynchronous );
+            PixmapRequest * p = new PixmapRequest( observer, pageNumber, tilesManager->width() / qApp->devicePixelRatio(), tilesManager->height() / qApp->devicePixelRatio(), 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/ui/pagepainter.cpp b/ui/pagepainter.cpp
index 4ecf84f7e..f471eb298 100644
--- a/ui/pagepainter.cpp
+++ b/ui/pagepainter.cpp
@@ -1,998 +1,998 @@
 /***************************************************************************
  *   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();
 
     /* Calculate the cropped geometry of the page */
     QRect scaledCrop = crop.geometry( scaledWidth, scaledHeight );
 
     /* variables prefixed with d are in the device pixels coordinate system, which translates to the rendered output - that means,
      * multiplied with the device pixel ratio of the target PaintDevice */
     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());
+    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());
 
     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 = page->_o_nearestPixmap( observer, dScaledWidth, dScaledHeight );
 
         if (p != NULL) {
             pixmap = *p;
             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 );
             }
             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 **/
     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 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();
                     tilePixmap->setDevicePixelRatio( qApp->devicePixelRatio() );
 
                     if ( tilePixmap->width() == dTileRect.width() && tilePixmap->height() == dTileRect.height() ) {
                         destPainter->drawPixmap( limitsInTile.topLeft(), *tilePixmap,
                                 dLimitsInTile.translated( -dTileRect.topLeft() ) );
                     } else {
                         destPainter->drawPixmap( tileRect, *tilePixmap );
                     }
                 }
                 tIt++;
             }
         }
         else
         {
             QPixmap scaledCroppedPixmap = pixmap.scaled(dScaledWidth, dScaledHeight).copy(dLimitsInPixmap);
             scaledCroppedPixmap.setDevicePixelRatio(dpr);
             destPainter->drawPixmap( limits.topLeft(), scaledCroppedPixmap, QRectF(0, 0, dLimits.width(),dLimits.height()));
         }
 
         // 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.setDevicePixelRatio(dpr);
         backImage.fill( paperColor );
         QPainter p( &backImage );
 
         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 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();
                     tilePixmap->setDevicePixelRatio( qApp->devicePixelRatio() );
 
                     if ( tilePixmap->width() == dTileRect.width() && tilePixmap->height() == dTileRect.height() )
                     {
                         p.drawPixmap( limitsInTile.translated( -limits.topLeft() ).topLeft(), *tilePixmap,
                                 dLimitsInTile.translated( -dTileRect.topLeft() ) );
                     }
                     else
                     {
                         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() ) );
                     }
                 }
                 ++tIt;
             }
         }
         else
         {
             // 4B.1. draw the page pixmap: normal or scaled
             QPixmap scaledCroppedPixmap = pixmap.scaled(dScaledWidth, dScaledHeight).copy(dLimitsInPixmap);
-            scaledCroppedPixmap.setDevicePixelRatio( dpr );
+            scaledCroppedPixmap.setDevicePixelRatio(dpr);
             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
             for (const auto& highlight : *bufferedHighlights)
             {
                 const Okular::NormalizedRect & r = highlight.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() );
 
                 const QColor highlightColor = highlight.first;
                 QPainter painter(&backImage);
                 painter.setCompositionMode(QPainter::CompositionMode_Multiply);
                 painter.fillRect(highlightRect, highlightColor);
             }
         }
 
         // 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 );
+        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 );
+                    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());
+                    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 );
+                    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;
 }
 
 
 /** 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, ceil( src->width() / dpr ), ceil( src->height() / dpr ) ) )
+    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( ceil( r.width() * dpr ), ceil( r.height() * dpr ), QImage::Format_ARGB32_Premultiplied );
-        croppedImage.setDevicePixelRatio( dpr );
+        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 b69f3ad25..05ade0274 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 );
         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( ceil(blendRect.width() * devicePixelRatioF()), ceil(blendRect.height() * devicePixelRatioF()) );
+                        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(),
-                                    ceil(blendRect.width() * devicePixelRatioF()), ceil(blendRect.height() * devicePixelRatioF()) );
+                                    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( ceil(blendRect.width()  * devicePixelRatioF()), ceil(blendRect.height()  * devicePixelRatioF()) );
+                            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(),
-                                        ceil(blendRect.width() * devicePixelRatioF()), ceil(blendRect.height() * devicePixelRatioF()) );
+                                        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;
             }
             // fallthrough
         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();
 }
 
 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(), 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(), 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(), 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()
 {
     PageViewItem currentPageItem = NULL;
     QSize viewportSize = viewport()->size();
     foreach ( const PageViewItem * pageItem, d->items )
     {
         if ( pageItem->isVisible() )
         {
             currentPageItem = *pageItem;
             break;
         }
     }
     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; */