diff --git a/CMakeLists.txt b/CMakeLists.txt
index ebdd4c8bd..d76f67e0c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,404 +1,405 @@
 cmake_minimum_required(VERSION 3.0)
 
 # KDE Application Version, managed by release script
 set (KDE_APPLICATIONS_VERSION_MAJOR "18")
 set (KDE_APPLICATIONS_VERSION_MINOR "03")
 set (KDE_APPLICATIONS_VERSION_MICRO "70")
 set (KDE_APPLICATIONS_VERSION "${KDE_APPLICATIONS_VERSION_MAJOR}.${KDE_APPLICATIONS_VERSION_MINOR}.${KDE_APPLICATIONS_VERSION_MICRO}")
 
 project(okular VERSION 1.3.${KDE_APPLICATIONS_VERSION_MICRO})
 
 set(QT_REQUIRED_VERSION "5.8.0")
 set(KF5_REQUIRED_VERSION "5.16.0")
 
 find_package(ECM 5.19.0 CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH})
 
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMOptionalAddSubdirectory)
 include(GenerateExportHeader)
 include(FeatureSummary)
 include(ECMAddAppIcon)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(ECMAddTests)
 include(ECMAddAppIcon)
 include(CMakePackageConfigHelpers)
 
 ecm_setup_version(${PROJECT_VERSION}
                   VARIABLE_PREFIX OKULAR
                   VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/core/version.h"
                   PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/Okular5ConfigVersion.cmake")
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED COMPONENTS Core DBus Test Widgets PrintSupport Svg Qml Quick)
 find_package(Qt5 ${QT_REQUIRED_VERSION} OPTIONAL_COMPONENTS TextToSpeech)
 if (NOT Qt5TextToSpeech_FOUND)
     message(STATUS "Qt5TextToSpeech not found, speech features will be disabled")
 else()
     add_definitions(-DHAVE_SPEECH)
 endif()
 
 find_package(KF5 ${KF5_REQUIRED_VERSION} REQUIRED COMPONENTS
     Archive
     Bookmarks
     Completion
     Config
     ConfigWidgets
     CoreAddons
     DocTools
     IconThemes
     JS
     KIO
     Parts
     ThreadWeaver
     Wallet
     WindowSystem
 )
 if(NOT WIN32)
     find_package(KF5 ${KF5_REQUIRED_VERSION} REQUIRED COMPONENTS
         Activities
     )
 endif()
 find_package(KF5Kirigami2)
 set_package_properties(KF5Kirigami2 PROPERTIES
     DESCRIPTION "A QtQuick based components set"
     PURPOSE "Required at runtime by the mobile app"
     TYPE RUNTIME
 )
 find_package(Phonon4Qt5 CONFIG REQUIRED)
 find_package(KDEExperimentalPurpose)
 set_package_properties(KDEExperimentalPurpose PROPERTIES
     DESCRIPTION "A framework for services and actions integration"
     PURPOSE "Required for enabling the share menu in Okular"
     TYPE OPTIONAL
 )
 if (KDEExperimentalPurpose_FOUND)
     set(PURPOSE_FOUND 1)
 else()
     set(PURPOSE_FOUND 0)
 endif()
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/cmake/modules)
 
 find_package(ZLIB REQUIRED)
 
 add_definitions(-DQT_USE_FAST_CONCATENATION -DQT_USE_FAST_OPERATOR_PLUS)
 add_definitions(-DTRANSLATION_DOMAIN="okular")
+add_definitions(-DQT_NO_URL_CAST_FROM_STRING)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${PHONON_INCLUDES} core/synctex ${ZLIB_INCLUDE_DIR} ${CMAKE_BINARY_DIR}/core)
 
 add_subdirectory( mobile )
 option(BUILD_COVERAGE "Build the project with gcov support" OFF)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "5.0.0")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wsuggest-override" )
     endif()
 endif()
 
 if(BUILD_COVERAGE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lgcov")
 endif()
 
 add_subdirectory( ui )
 add_subdirectory( shell )
 add_subdirectory( generators )
 add_subdirectory( autotests )
 add_subdirectory( conf/autotests )
 
 add_subdirectory(doc)
 
 include(OkularConfigureChecks.cmake)
 
 if(NOT WIN32)
  set(MATH_LIB m)
 else(NOT WIN32)
  set(MATH_LIB)
 endif(NOT WIN32)
 
 # okularcore
 
 set(okularcore_SRCS
    core/action.cpp
    core/annotations.cpp
    core/area.cpp
    core/audioplayer.cpp
    core/bookmarkmanager.cpp
    core/chooseenginedialog.cpp
    core/document.cpp
    core/documentcommands.cpp
    core/fontinfo.cpp
    core/form.cpp
    core/generator.cpp
    core/generator_p.cpp
    core/misc.cpp
    core/movie.cpp
    core/observer.cpp
    core/debug.cpp
    core/page.cpp
    core/pagecontroller.cpp
    core/pagesize.cpp
    core/pagetransition.cpp
    core/rotationjob.cpp
    core/scripter.cpp
    core/sound.cpp
    core/sourcereference.cpp
    core/textdocumentgenerator.cpp
    core/textdocumentsettings.cpp
    core/textpage.cpp
    core/tilesmanager.cpp
    core/utils.cpp
    core/view.cpp
    core/fileprinter.cpp
    core/script/executor_kjs.cpp
    core/script/kjs_app.cpp
    core/script/kjs_console.cpp
    core/script/kjs_data.cpp
    core/script/kjs_document.cpp
    core/script/kjs_fullscreen.cpp
    core/script/kjs_field.cpp
    core/script/kjs_spell.cpp
    core/script/kjs_util.cpp
    core/synctex/synctex_parser.c
    core/synctex/synctex_parser_utils.c
 )
 
 ki18n_wrap_ui(okularcore_SRCS
    conf/textdocumentsettings.ui
 )
 
 install( FILES
            core/action.h
            core/annotations.h
            core/area.h
            core/document.h
            core/fontinfo.h
            core/form.h
            core/generator.h
            core/global.h
            core/page.h
            core/pagesize.h
            core/pagetransition.h
            core/sound.h
            core/sourcereference.h
            core/textdocumentgenerator.h
            core/textdocumentsettings.h
            core/textpage.h
            core/tile.h
            core/utils.h
            core/fileprinter.h
            core/observer.h
            ${CMAKE_CURRENT_BINARY_DIR}/core/version.h
            ${CMAKE_CURRENT_BINARY_DIR}/core/okularcore_export.h
            ${CMAKE_CURRENT_BINARY_DIR}/settings_core.h
          DESTINATION ${KDE_INSTALL_INCLUDEDIR}/okular/core COMPONENT Devel)
 
 install( FILES
            interfaces/configinterface.h
            interfaces/guiinterface.h
            interfaces/printinterface.h
            interfaces/saveinterface.h
            interfaces/viewerinterface.h
          DESTINATION ${KDE_INSTALL_INCLUDEDIR}/okular/interfaces COMPONENT Devel)
 
 ki18n_wrap_ui(okularcore_SRCS
    core/chooseenginewidget.ui
 )
 
 kconfig_add_kcfg_files(okularcore_SRCS conf/settings_core.kcfgc)
 
 add_library(okularcore SHARED ${okularcore_SRCS})
 generate_export_header(okularcore BASE_NAME okularcore EXPORT_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/core/okularcore_export.h")
 
 # Special handling for linking okularcore on OSX/Apple
 IF(APPLE)
     SET(OKULAR_IOKIT "-framework IOKit" CACHE STRING "Apple IOKit framework")
 ENDIF(APPLE)
 
 # Extra library needed by imported synctex code on Windows
 if(WIN32)
     set(SHLWAPI shlwapi)
 endif(WIN32)
 
 target_link_libraries(okularcore
 PRIVATE
     ${OKULAR_IOKIT}
     ${SHLWAPI}
     KF5::Archive
     KF5::JS
     KF5::JSApi
     KF5::KIOCore
     KF5::KIOWidgets
     KF5::I18n
     KF5::ThreadWeaver
     KF5::Wallet
     KF5::Bookmarks
     Phonon::phonon4qt5
     ${MATH_LIB}
     ${ZLIB_LIBRARIES}
 PUBLIC  # these are included from the installed headers
     KF5::CoreAddons
     KF5::XmlGui
     KF5::ConfigGui
     Qt5::PrintSupport
     Qt5::Widgets
 )
 
 set_target_properties(okularcore PROPERTIES VERSION 8.0.0 SOVERSION 8 OUTPUT_NAME Okular5Core EXPORT_NAME Core)
 
 install(TARGETS okularcore EXPORT Okular5Targets ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 
 install(FILES conf/okular.kcfg DESTINATION ${KDE_INSTALL_KCFGDIR})
 install(FILES conf/okular_core.kcfg DESTINATION ${KDE_INSTALL_KCFGDIR})
 install(FILES core/okularGenerator.desktop DESTINATION ${KDE_INSTALL_KSERVICETYPES5DIR})
 
 # okularpart
 
 set(okularpart_conf_SRCS
    conf/preferencesdialog.cpp
    conf/dlgaccessibility.cpp
    conf/dlgdebug.cpp
    conf/dlgeditor.cpp
    conf/dlggeneral.cpp
    conf/dlgannotations.cpp
    conf/dlgperformance.cpp
    conf/dlgpresentation.cpp
    conf/editannottooldialog.cpp
    conf/editdrawingtooldialog.cpp
    conf/widgetannottools.cpp
    conf/widgetconfigurationtoolsbase.cpp
    conf/widgetdrawingtools.cpp
 )
 
 set(okularpart_SRCS
    ${okularpart_conf_SRCS}
    part.cpp
    extensions.cpp
    ui/embeddedfilesdialog.cpp
    ui/annotwindow.cpp
    ui/annotationmodel.cpp
    ui/annotationpopup.cpp
    ui/annotationpropertiesdialog.cpp
    ui/annotationproxymodels.cpp
    ui/annotationtools.cpp
    ui/annotationwidgets.cpp
    ui/bookmarklist.cpp
    ui/debug_ui.cpp
    ui/drawingtoolactions.cpp
    ui/fileprinterpreview.cpp
    ui/findbar.cpp
    ui/formwidgets.cpp
    ui/guiutils.cpp
    ui/ktreeviewsearchline.cpp
    ui/latexrenderer.cpp
    ui/minibar.cpp
    ui/okmenutitle.cpp
    ui/pageitemdelegate.cpp
    ui/pagepainter.cpp
    ui/pagesizelabel.cpp
    ui/pageviewannotator.cpp
    ui/pageviewmouseannotation.cpp
    ui/pageview.cpp
    ui/magnifierview.cpp
    ui/pageviewutils.cpp
    ui/presentationsearchbar.cpp
    ui/presentationwidget.cpp
    ui/propertiesdialog.cpp
    ui/searchlineedit.cpp
    ui/searchwidget.cpp
    ui/sidebar.cpp
    ui/side_reviews.cpp
    ui/snapshottaker.cpp
    ui/thumbnaillist.cpp
    ui/toc.cpp
    ui/tocmodel.cpp
    ui/toolaction.cpp
    ui/videowidget.cpp
    ui/layers.cpp
 )
 
 if (Qt5TextToSpeech_FOUND)
    set(okularpart_SRCS ${okularpart_SRCS}
       ui/tts.cpp)
 endif()
 
 ki18n_wrap_ui(okularpart_SRCS
    conf/dlgaccessibilitybase.ui
    conf/dlgeditorbase.ui
    conf/dlggeneralbase.ui
    conf/dlgannotationsbase.ui
    conf/dlgperformancebase.ui
    conf/dlgpresentationbase.ui
 )
 
 kconfig_add_kcfg_files(okularpart_SRCS conf/settings.kcfgc)
 
 add_library(okularpart SHARED ${okularpart_SRCS})
 generate_export_header(okularpart BASE_NAME okularpart)
 
 target_link_libraries(okularpart okularcore
     ${MATH_LIB}
     Qt5::Svg
     Phonon::phonon4qt5
     KF5::Archive
     KF5::Bookmarks
     KF5::I18n
     KF5::IconThemes
     KF5::ItemViews
     KF5::KIOCore
     KF5::KIOFileWidgets
     KF5::KIOWidgets
     KF5::KIONTLM
     KF5::Parts
     KF5::Solid
     KF5::Wallet
     KF5::WindowSystem
 )
 
 if (KDEExperimentalPurpose_FOUND)
     target_link_libraries(okularpart KDEExperimental::PurposeWidgets)
 endif()
 
 set_target_properties(okularpart PROPERTIES PREFIX "")
 
 if (Qt5TextToSpeech_FOUND)
    target_link_libraries(okularpart Qt5::TextToSpeech)
 endif()
 install(TARGETS okularpart DESTINATION ${KDE_INSTALL_PLUGINDIR})
 
 
 ########### install files ###############
 
 install(FILES okular.upd DESTINATION ${KDE_INSTALL_DATADIR}/kconf_update)
 
 install( FILES okular_part.desktop  DESTINATION  ${KDE_INSTALL_KSERVICES5DIR} )
 install( FILES part.rc part-viewermode.rc DESTINATION ${KDE_INSTALL_KXMLGUI5DIR}/okular )
 
 install( FILES okular.categories DESTINATION ${KDE_INSTALL_CONFDIR} )
 
 ########### cmake files #################
 
 set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/Okular5")
 configure_package_config_file(
   "${CMAKE_CURRENT_SOURCE_DIR}/Okular5Config.cmake.in"
   "${CMAKE_CURRENT_BINARY_DIR}/Okular5Config.cmake"
   INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
   PATH_VARS  INCLUDE_INSTALL_DIR CMAKE_INSTALL_PREFIX
 )
 
 install(FILES
   "${CMAKE_CURRENT_BINARY_DIR}/Okular5Config.cmake"
   "${CMAKE_CURRENT_BINARY_DIR}/Okular5ConfigVersion.cmake"
   DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
   COMPONENT Devel
 )
 
 install(EXPORT Okular5Targets DESTINATION "${CMAKECONFIG_INSTALL_DIR}" FILE Okular5Targets.cmake NAMESPACE Okular::)
 
 ########### summary #################
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
diff --git a/generators/chm/generator_chm.cpp b/generators/chm/generator_chm.cpp
index 4913f46f3..ada9b3d53 100644
--- a/generators/chm/generator_chm.cpp
+++ b/generators/chm/generator_chm.cpp
@@ -1,448 +1,448 @@
 /***************************************************************************
  *   Copyright (C) 2005 by Piotr Szymański <niedakh@gmail.com>             *
  *   Copyright (C) 2008 by Albert Astals Cid <aacid@kde.org>               *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  ***************************************************************************/
 
 #include "generator_chm.h"
 
 #include <QEventLoop>
 #include <QMutex>
 #include <QPainter>
 #include <QDomElement>
 
 #include <KAboutData>
 #include <khtml_part.h>
 #include <khtmlview.h>
 #include <KLocalizedString>
 #include <QUrl>
 #include <dom/html_misc.h>
 #include <dom/dom_node.h>
 #include <dom/dom_html.h>
 
 #include <core/action.h>
 #include <core/page.h>
 #include <core/textpage.h>
 #include <core/utils.h>
 
 OKULAR_EXPORT_PLUGIN(CHMGenerator, "libokularGenerator_chmlib.json")
 
 static QString absolutePath( const QString &baseUrl, const QString &path )
 {
     QString absPath;
     if ( path.startsWith(QLatin1Char( '/' )) )
     {
         // already absolute
         absPath = path;
     }
     else
     {
         QUrl url = QUrl::fromLocalFile( baseUrl ).adjusted(QUrl::RemoveFilename);
         url.setPath( url.path() + path );
         absPath = url.toLocalFile();
     }
     return absPath;
 }
 
 CHMGenerator::CHMGenerator( QObject *parent, const QVariantList &args )
     : Okular::Generator( parent, args )
 {
     setFeature( TextExtraction );
 
     m_syncGen=0;
     m_file=0;
     m_request = 0;
 }
 
 CHMGenerator::~CHMGenerator()
 {
     delete m_syncGen;
 }
 
 bool CHMGenerator::loadDocument( const QString & fileName, QVector< Okular::Page * > & pagesVector )
 {
     m_file = new EBook_CHM();
     m_file = EBook::loadFile( fileName );
     if (!m_file)
     {
         return false;
     }
     m_fileName=fileName;
     QList< EBookTocEntry > topics;
     m_file->getTableOfContents(topics);
     
     // fill m_docSyn
     QMap<int, QDomElement> lastIndentElement;
     QMap<QString, int> tmpPageList;
     int pageNum = 0;
 
     foreach(const EBookTocEntry &e, topics)
     {
         QDomElement item = m_docSyn.createElement(e.name);
         if (!e.url.isEmpty())
         {
             QString url = e.url.toString();
             item.setAttribute(QStringLiteral("ViewportName"), url);
             if(!tmpPageList.contains(url))
             {//add a page only once
                 tmpPageList.insert(url, pageNum);
                 pageNum++;
             }
         }
         item.setAttribute(QStringLiteral("Icon"), e.iconid);
         if (e.indent == 0) m_docSyn.appendChild(item);
         else lastIndentElement[e.indent - 1].appendChild(item);
         lastIndentElement[e.indent] = item;
     }
     
     // fill m_urlPage and m_pageUrl
     QList<QUrl> pageList;
     m_file->enumerateFiles(pageList);
-    const QString home = m_file->homeUrl().toString();
-    if (home != QLatin1String("/"))
+    const QUrl home = m_file->homeUrl();
+    if (home.path() != QLatin1String("/"))
         pageList.prepend(home);
     m_pageUrl.resize(pageNum);
 
     foreach (const QUrl &qurl, pageList)
     {
         QString url = qurl.toString();
         const QString urlLower = url.toLower();
         if (!urlLower.endsWith(QLatin1String(".html")) && !urlLower.endsWith(QLatin1String(".htm")))
             continue;
 
         int pos = url.indexOf (QLatin1Char(('#')));
         // insert the url into the maps, but insert always the variant without the #ref part
         QString tmpUrl = pos == -1 ? url : url.left(pos);
 
         // url already there, abort insertion
         if (m_urlPage.contains(tmpUrl)) continue;
 
         int foundPage = tmpPageList.value(tmpUrl, -1);
         if (foundPage != -1 ) {
             m_urlPage.insert(tmpUrl, foundPage);
             m_pageUrl[foundPage] = tmpUrl;
         } else {
             //add pages not present in toc
             m_urlPage.insert(tmpUrl, pageNum);
             m_pageUrl.append(tmpUrl);
             pageNum++;
         }
     }
 
     pagesVector.resize(m_pageUrl.count());
     m_textpageAddedList.fill(false, pagesVector.count());
     m_rectsGenerated.fill(false, pagesVector.count());
 
     if (!m_syncGen)
     {
         m_syncGen = new KHTMLPart();
     }
     disconnect( m_syncGen, 0, this, 0 );
 
     for (int i = 0; i < m_pageUrl.count(); ++i)
     {
         preparePageForSyncOperation(m_pageUrl.at(i));
         pagesVector[ i ] = new Okular::Page (i, m_syncGen->view()->contentsWidth(),
             m_syncGen->view()->contentsHeight(), Okular::Rotation0 );
     }
 
     connect( m_syncGen, SIGNAL(completed()), this, SLOT(slotCompleted()) );
     connect( m_syncGen, &KParts::ReadOnlyPart::canceled, this, &CHMGenerator::slotCompleted );
 
     return true;
 }
 
 bool CHMGenerator::doCloseDocument()
 {
     // delete the document information of the old document
     delete m_file;
     m_file=0;
     m_textpageAddedList.clear();
     m_rectsGenerated.clear();
     m_urlPage.clear();
     m_pageUrl.clear();
     m_docSyn.clear();
     if (m_syncGen)
     {
         m_syncGen->closeUrl();
     }
 
     return true;
 }
 
 void CHMGenerator::preparePageForSyncOperation(const QString & url)
 {
     QString pAddress = QStringLiteral("ms-its:") + m_fileName + QStringLiteral("::") + m_file->urlToPath(QUrl(url));
     m_chmUrl = url;
 
     m_syncGen->openUrl(QUrl(pAddress));
     m_syncGen->view()->layout();
 
     QEventLoop loop;
     connect( m_syncGen, SIGNAL(completed()), &loop, SLOT(quit()) );
     connect( m_syncGen, &KParts::ReadOnlyPart::canceled, &loop, &QEventLoop::quit );
     // discard any user input, otherwise it breaks the "synchronicity" of this
     // function
     loop.exec( QEventLoop::ExcludeUserInputEvents );
 }
 
 void CHMGenerator::slotCompleted()
 {
     if ( !m_request )
         return;
 
     QImage image( m_request->width(), m_request->height(), QImage::Format_ARGB32 );
     image.fill( Qt::white );
 
     QPainter p( &image );
     QRect r( 0, 0, m_request->width(), m_request->height() );
 
     bool moreToPaint;
     m_syncGen->paint( &p, r, 0, &moreToPaint );
 
     p.end();
 
     if ( !m_textpageAddedList.at( m_request->pageNumber() ) ) {
         additionalRequestData();
         m_textpageAddedList[ m_request->pageNumber() ] = true;
     }
 
     m_syncGen->closeUrl();
     m_chmUrl = QString();
 
     userMutex()->unlock();
 
     Okular::PixmapRequest *req = m_request;
     m_request = 0;
 
     if ( !req->page()->isBoundingBoxKnown() )
         updatePageBoundingBox( req->page()->number(), Okular::Utils::imageBoundingBox( &image ) );
     req->page()->setPixmap( req->observer(), new QPixmap( QPixmap::fromImage( image ) ) );
     signalPixmapRequestDone( req );
 }
 
 Okular::DocumentInfo CHMGenerator::generateDocumentInfo( const QSet<Okular::DocumentInfo::Key> &keys ) const
 {
     Okular::DocumentInfo docInfo;
     if ( keys.contains( Okular::DocumentInfo::MimeType ) )
         docInfo.set( Okular::DocumentInfo::MimeType, QStringLiteral("application/x-chm") );
     if ( keys.contains( Okular::DocumentInfo::Title ) )
         docInfo.set( Okular::DocumentInfo::Title, m_file->title() );
     return docInfo;
 }
 
 const Okular::DocumentSynopsis * CHMGenerator::generateDocumentSynopsis()
 {
     return &m_docSyn;
 }
 
 bool CHMGenerator::canGeneratePixmap () const
 {
     bool isLocked = true;
     if ( userMutex()->tryLock() ) {
         userMutex()->unlock();
         isLocked = false;
     }
 
     return !isLocked;
 }
 
 void CHMGenerator::generatePixmap( Okular::PixmapRequest * request ) 
 {
     int requestWidth = request->width();
     int requestHeight = request->height();
 
     userMutex()->lock();
     QString url= m_pageUrl[request->pageNumber()];
 
     QString pAddress= QStringLiteral("ms-its:") + m_fileName + QStringLiteral("::") + m_file->urlToPath(QUrl(url));
     m_chmUrl = url;
     m_syncGen->view()->resizeContents(requestWidth,requestHeight);
     m_request=request;
     // will emit openURL without problems
     m_syncGen->openUrl ( QUrl(pAddress) );
 }
 
 
 void CHMGenerator::recursiveExploreNodes(DOM::Node node,Okular::TextPage *tp)
 {
     if (node.nodeType() == DOM::Node::TEXT_NODE && !node.getRect().isNull())
     {
         QString nodeText=node.nodeValue().string();
         QRect r=node.getRect();
         int vWidth=m_syncGen->view()->width();
         int vHeight=m_syncGen->view()->height();
         Okular::NormalizedRect *nodeNormRect;
 #define NOEXP
 #ifndef NOEXP
         int x,y,height;
         int x_next,y_next,height_next;
         int nodeTextLength = nodeText.length();
         if (nodeTextLength==1)
         {
             nodeNormRect=new Okular::NormalizedRect (r,vWidth,vHeight);
             tp->append(nodeText,nodeNormRect,nodeNormRect->bottom,0,(nodeText=="\n"));
         }
         else
         {
             for (int i=0;i<nodeTextLength;i++)
             { 
                 node.getCursor(i,x,y,height);
                 if (i==0)
                 // i is 0, use left rect boundary
                 {
 //                     if (nodeType[i+1]
                     node.getCursor(i+1,x_next,y_next,height_next);
                     nodeNormRect=new Okular::NormalizedRect (QRect(x,y,x_next-x-1,height),vWidth,vHeight);
                 }
                 else if ( i <nodeTextLength -1 )
                 // i is between zero and the last element
                 {
                     node.getCursor(i+1,x_next,y_next,height_next);
                     nodeNormRect=new Okular::NormalizedRect (QRect(x,y,x_next-x-1,height),vWidth,vHeight);
                 }
                 else
                 // the last element use right rect boundary
                 {
                     node.getCursor(i-1,x_next,y_next,height_next);
             }
         }
 #else
         nodeNormRect=new Okular::NormalizedRect (r,vWidth,vHeight);
         tp->append(nodeText,nodeNormRect/*,0*/);
 #endif
     }
     DOM::Node child = node.firstChild();
     while ( !child.isNull() )
     {
         recursiveExploreNodes(child,tp);
         child = child.nextSibling();
     }
 }
 
 void CHMGenerator::additionalRequestData() 
 {
     Okular::Page * page=m_request->page();
     const bool genObjectRects = !m_rectsGenerated.at( m_request->page()->number() );
     const bool genTextPage = !m_request->page()->hasTextPage() && genObjectRects;
 
     if (genObjectRects || genTextPage )
     {
         DOM::HTMLDocument domDoc=m_syncGen->htmlDocument();
         // only generate object info when generating a full page not a thumbnail
         if ( genObjectRects )
         {
             QLinkedList< Okular::ObjectRect * > objRects;
             int xScale=m_syncGen->view()->width();
             int yScale=m_syncGen->view()->height();
             // getting links
             DOM::HTMLCollection coll=domDoc.links();
             DOM::Node n;
             QRect r;
             if (! coll.isNull() )
             {
                 int size=coll.length();
                 for(int i=0;i<size;i++)
                 {
                     n=coll.item(i);
                     if ( !n.isNull() )
                     {
                         QString url = n.attributes().getNamedItem("href").nodeValue().string();
                         r=n.getRect();
                         // there is no way for us to support javascript properly
                         if (url.startsWith(QLatin1String("JavaScript:")), Qt::CaseInsensitive)
                             continue;
                         else if (url.contains (QStringLiteral(":")))
                         {
                             objRects.push_back(
                                 new Okular::ObjectRect ( Okular::NormalizedRect(r,xScale,yScale),
                                 false,
                                 Okular::ObjectRect::Action,
                                 new Okular::BrowseAction ( QUrl(url) )));
                         }
                         else
                         {
                             Okular::DocumentViewport viewport( metaData( QStringLiteral("NamedViewport"), absolutePath( m_chmUrl, url ) ).toString() );
                             objRects.push_back(
                                 new Okular::ObjectRect ( Okular::NormalizedRect(r,xScale,yScale),
                                 false,
                                 Okular::ObjectRect::Action,
                                 new Okular::GotoAction ( QString::null, viewport)));	//krazy:exclude=nullstrassign for old broken gcc
                         }
                     }
                 }
             }
 
             // getting images
             coll=domDoc.images();
             if (! coll.isNull() )
             {
                 int size=coll.length();
                 for(int i=0;i<size;i++)
                 {
                     n=coll.item(i);
                     if ( !n.isNull() )
                     {
                         objRects.push_back(
                                 new Okular::ObjectRect ( Okular::NormalizedRect(n.getRect(),xScale,yScale),
                                 false,
                                 Okular::ObjectRect::Image,
                                 0));
                     }
                 }
             }
             m_request->page()->setObjectRects( objRects );
             m_rectsGenerated[ m_request->page()->number() ] = true;
         }
 
         if ( genTextPage )
         {
             Okular::TextPage *tp=new Okular::TextPage();
             recursiveExploreNodes(domDoc,tp);
             page->setTextPage (tp);
         }
     }
 }
 
 Okular::TextPage* CHMGenerator::textPage( Okular::Page * page )
 {
     userMutex()->lock();
 
     m_syncGen->view()->resize(page->width(), page->height());
     
     preparePageForSyncOperation(m_pageUrl[page->number()]);
     Okular::TextPage *tp=new Okular::TextPage();
     recursiveExploreNodes( m_syncGen->htmlDocument(), tp);
     userMutex()->unlock();
     return tp;
 }
 
 QVariant CHMGenerator::metaData( const QString &key, const QVariant &option ) const
 {
     if ( key == QLatin1String("NamedViewport") && !option.toString().isEmpty() )
     {
         const int pos = option.toString().indexOf(QLatin1Char('#'));
         QString tmpUrl = pos == -1 ? option.toString() : option.toString().left(pos);
         Okular::DocumentViewport viewport;
         QMap<QString,int>::const_iterator it = m_urlPage.find(tmpUrl);
         if (it != m_urlPage.end())
         {
             viewport.pageNumber = it.value();
             return viewport.toString();
         }
         
     }
     else if ( key == QLatin1String("DocumentTitle") )
     {
         return m_file->title();
     }
     return QVariant();
 }
 
 /* kate: replace-tabs on; tab-width 4; */
 
 #include "generator_chm.moc"