# -*- coding: utf-8 -*-

# Copyright (c) 2002 - 2019 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing the helpviewer main window.
"""

from __future__ import unicode_literals
try:
    str = unicode
except NameError:
    pass

import os

from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QSize, QTimer, \
    QUrl, QThread, QTextCodec, QFileInfo
from PyQt5.QtGui import QDesktopServices, QKeySequence, QFont, QFontMetrics, \
    QIcon
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QSizePolicy, QDockWidget, \
    QComboBox, QLabel, QSplitter, QMenu, QToolButton, QLineEdit, \
    QApplication, QWhatsThis, QDialog, QHBoxLayout, QProgressBar, QAction, \
    QInputDialog
from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest
from PyQt5.QtWebKit import QWebSettings, QWebDatabase, QWebSecurityOrigin
from PyQt5.QtWebKitWidgets import QWebPage
try:
    from PyQt5.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
    QTHELP_AVAILABLE = True
except ImportError:
    QTHELP_AVAILABLE = False

from .Network.NetworkAccessManager import SSL_AVAILABLE

from .data import icons_rc          # __IGNORE_WARNING__
from .data import html_rc           # __IGNORE_WARNING__
from .data import javascript_rc     # __IGNORE_WARNING__

from E5Gui.E5Action import E5Action
from E5Gui import E5MessageBox, E5FileDialog, E5ErrorMessage
from E5Gui.E5MainWindow import E5MainWindow
from E5Gui.E5Application import e5App
from E5Gui.E5ZoomWidget import E5ZoomWidget

from E5Network.E5NetworkIcon import E5NetworkIcon

import Preferences
from Preferences import Shortcuts

import Utilities
import Globals

import UI.PixmapCache
import UI.Config
from UI.Info import Version

from .HelpSingleApplication import HelpSingleApplicationServer


class HelpWindow(E5MainWindow):
    """
    Class implementing the web browser main window.
    
    @signal helpClosed() emitted after the window was requested to close down
    @signal zoomTextOnlyChanged(bool) emitted after the zoom text only setting
        was changed
    @signal privacyChanged(bool) emitted to indicate a new privacy mode
    """
    zoomTextOnlyChanged = pyqtSignal(bool)
    helpClosed = pyqtSignal()
    privacyChanged = pyqtSignal(bool)
    
    helpwindows = []

    _useQtHelp = QTHELP_AVAILABLE
    
    _networkAccessManager = None
    _cookieJar = None
    _helpEngine = None
    _bookmarksManager = None
    _historyManager = None
    _passwordManager = None
    _adblockManager = None
    _downloadManager = None
    _feedsManager = None
    _userAgentsManager = None
    _syncManager = None
    _speedDial = None
    _personalInformationManager = None
    _greaseMonkeyManager = None
    _notification = None
    _featurePermissionManager = None
    _flashCookieManager = None
    _zoomManager = None
    
    def __init__(self, home, path, parent, name,
                 searchWord=None, qthelp=False, single=False, saname=""):
        """
        Constructor
        
        @param home the URL to be shown
        @type str
        @param path the path of the working dir (usually '.')
        @type str
        @param parent parent widget of this window
        @type QWidget
        @param name name of this window
        @type str
        @param searchWord word to search for
        @type str
        @param qthelp flag indicating to enable the QtHelp support
        @type bool
        @param single flag indicating to start in single application mode
        @type bool
        @param saname name to be used for the single application server
        @type str
        """
        super(HelpWindow, self).__init__(parent)
        self.setObjectName(name)
        self.setWindowTitle(self.tr("eric6 Web Browser"))
        
        self.setWindowIcon(UI.PixmapCache.getIcon("ericWeb.png"))

        self.mHistory = []
        self.__lastConfigurationPageName = ""
        self.__lastActiveWindow = None
        
        self.__shortcutsDialog = None
        
        self.__eventMouseButtons = Qt.NoButton
        self.__eventKeyboardModifiers = Qt.NoModifier
        
        HelpWindow.setUseQtHelp(qthelp or bool(searchWord))
            
        from .SearchWidget import SearchWidget
        from .HelpTocWidget import HelpTocWidget
        from .HelpIndexWidget import HelpIndexWidget
        from .HelpSearchWidget import HelpSearchWidget
        from .HelpBrowserWV import HelpBrowser
        from .HelpTabWidget import HelpTabWidget
        from .AdBlock.AdBlockIcon import AdBlockIcon
        from .VirusTotal.VirusTotalApi import VirusTotalAPI
    
        self.setStyle(Preferences.getUI("Style"),
                      Preferences.getUI("StyleSheet"))
        
        # initialize some SSL stuff
        from E5Network.E5SslUtilities import initSSL
        initSSL()
        
        if HelpWindow._useQtHelp:
            self.__helpEngine = QHelpEngine(
                HelpWindow.getQtHelpCollectionFileName(),
                self)
            self.__removeOldDocumentation()
            self.__helpEngine.warning.connect(self.__warning)
        else:
            self.__helpEngine = None
        self.__helpInstaller = None
        
        self.__zoomWidget = E5ZoomWidget(
            UI.PixmapCache.getPixmap("zoomOut.png"),
            UI.PixmapCache.getPixmap("zoomIn.png"),
            UI.PixmapCache.getPixmap("zoomReset.png"), self)
        self.statusBar().addPermanentWidget(self.__zoomWidget)
        self.__zoomWidget.setMapping(
            HelpBrowser.ZoomLevels, HelpBrowser.ZoomLevelDefault)
        self.__zoomWidget.valueChanged.connect(self.__zoomValueChanged)
        
        self.tabWidget = HelpTabWidget(self)
        self.tabWidget.currentChanged[int].connect(self.__currentChanged)
        self.tabWidget.titleChanged.connect(self.__titleChanged)
        self.tabWidget.showMessage.connect(self.statusBar().showMessage)
        self.tabWidget.browserZoomValueChanged.connect(
            self.__zoomWidget.setValue)
        
        self.findDlg = SearchWidget(self, self)
        centralWidget = QWidget()
        layout = QVBoxLayout()
        layout.setContentsMargins(1, 1, 1, 1)
        layout.addWidget(self.tabWidget)
        layout.addWidget(self.findDlg)
        self.tabWidget.setSizePolicy(
            QSizePolicy.Preferred, QSizePolicy.Expanding)
        centralWidget.setLayout(layout)
        self.setCentralWidget(centralWidget)
        self.findDlg.hide()
        
        if HelpWindow._useQtHelp:
            # setup the TOC widget
            self.__tocWindow = HelpTocWidget(self.__helpEngine, self)
            self.__tocDock = QDockWidget(self.tr("Contents"), self)
            self.__tocDock.setObjectName("TocWindow")
            self.__tocDock.setWidget(self.__tocWindow)
            self.addDockWidget(Qt.LeftDockWidgetArea, self.__tocDock)
            
            # setup the index widget
            self.__indexWindow = HelpIndexWidget(self.__helpEngine, self)
            self.__indexDock = QDockWidget(self.tr("Index"), self)
            self.__indexDock.setObjectName("IndexWindow")
            self.__indexDock.setWidget(self.__indexWindow)
            self.addDockWidget(Qt.LeftDockWidgetArea, self.__indexDock)
            
            # setup the search widget
            self.__searchWord = searchWord
            self.__indexing = False
            self.__indexingProgress = None
            self.__searchEngine = self.__helpEngine.searchEngine()
            self.__searchEngine.indexingStarted.connect(
                self.__indexingStarted)
            self.__searchEngine.indexingFinished.connect(
                self.__indexingFinished)
            self.__searchWindow = HelpSearchWidget(
                self.__searchEngine, self)
            self.__searchDock = QDockWidget(self.tr("Search"), self)
            self.__searchDock.setObjectName("SearchWindow")
            self.__searchDock.setWidget(self.__searchWindow)
            self.addDockWidget(Qt.LeftDockWidgetArea, self.__searchDock)
        
        if Preferences.getHelp("SaveGeometry"):
            g = Preferences.getGeometry("HelpViewerGeometry")
        else:
            g = QByteArray()
        if g.isEmpty():
            s = QSize(800, 800)
            self.resize(s)
        else:
            self.restoreGeometry(g)
        
        self.__setIconDatabasePath()
        self.__initWebSettings()
        
        self.__initActions()
        self.__initMenus()
        self.__initToolbars()
        
        self.historyManager()
        
        syncMgr = self.syncManager()
        syncMgr.syncMessage.connect(self.statusBar().showMessage)
        syncMgr.syncError.connect(self.statusBar().showMessage)
        
        self.tabWidget.newBrowser(home)
        self.tabWidget.currentBrowser().setFocus()
        
        self.__class__.helpwindows.append(self)
        
        self.__adBlockIcon = AdBlockIcon(self)
        self.statusBar().addPermanentWidget(self.__adBlockIcon)
        self.__adBlockIcon.setEnabled(
            Preferences.getHelp("AdBlockEnabled"))
        self.tabWidget.currentChanged[int].connect(
            self.__adBlockIcon.currentChanged)
        self.tabWidget.sourceChanged.connect(
            self.__adBlockIcon.sourceChanged)
        
        self.networkIcon = E5NetworkIcon(self)
        self.statusBar().addPermanentWidget(self.networkIcon)
        
        if len(HelpWindow.helpwindows):
            QDesktopServices.setUrlHandler(
                "http", HelpWindow.helpwindows[0].urlHandler)
            QDesktopServices.setUrlHandler(
                "https", HelpWindow.helpwindows[0].urlHandler)
        
        # setup connections
        self.__activating = False
        if HelpWindow._useQtHelp:
            # TOC window
            self.__tocWindow.linkActivated.connect(self.__linkActivated)
            self.__tocWindow.escapePressed.connect(
                self.__activateCurrentBrowser)
            
            # index window
            self.__indexWindow.linkActivated.connect(self.__linkActivated)
            self.__indexWindow.linksActivated.connect(
                self.__linksActivated)
            self.__indexWindow.escapePressed.connect(
                self.__activateCurrentBrowser)
            
            # search window
            self.__searchWindow.linkActivated.connect(
                self.__linkActivated)
            self.__searchWindow.escapePressed.connect(
                self.__activateCurrentBrowser)
        
        state = Preferences.getHelp("HelpViewerState")
        self.restoreState(state)
        
        self.__initHelpDb()
        
        self.__virusTotal = VirusTotalAPI(self)
        self.__virusTotal.submitUrlError.connect(
            self.__virusTotalSubmitUrlError)
        self.__virusTotal.urlScanReport.connect(
            self.__virusTotalUrlScanReport)
        self.__virusTotal.fileScanReport.connect(
            self.__virusTotalFileScanReport)
        
        self.__shutdownCalled = False
        
        self.flashCookieManager()
        
        if single:
            self.SAServer = HelpSingleApplicationServer(saname)
            self.SAServer.loadUrl.connect(self.__saLoadUrl)
            self.SAServer.newTab.connect(self.__saNewTab)
            self.SAServer.search.connect(self.__saSearchWord)
            self.SAServer.shutdown.connect(self.shutdown)
        else:
            self.SAServer = None
        
        if HelpWindow._useQtHelp:
            QTimer.singleShot(50, self.__lookForNewDocumentation)
            if self.__searchWord is not None:
                QTimer.singleShot(0, self.__searchForWord)
        
        e5App().focusChanged.connect(self.__appFocusChanged)
        
        QTimer.singleShot(0, syncMgr.loadSettings)
    
    def __del__(self):
        """
        Special method called during object destruction.
        
        Note: This empty variant seems to get rid of the Qt message
        'Warning: QBasicTimer::start: QBasicTimer can only be used with
        threads started with QThread'
        """
        pass
    
    def __setIconDatabasePath(self, enable=True):
        """
        Private method to set the favicons path.
        
        @param enable flag indicating to enabled icon storage (boolean)
        """
        if enable:
            iconDatabasePath = os.path.join(Utilities.getConfigDir(),
                                            "browser", "favicons")
            if not os.path.exists(iconDatabasePath):
                os.makedirs(iconDatabasePath)
        else:
            iconDatabasePath = ""   # setting an empty path disables it
        QWebSettings.setIconDatabasePath(iconDatabasePath)
        
    def __initWebSettings(self):
        """
        Private method to set the global web settings.
        """
        standardFont = Preferences.getHelp("StandardFont")
        fixedFont = Preferences.getHelp("FixedFont")

        settings = QWebSettings.globalSettings()
        settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
        
        settings.setFontFamily(QWebSettings.StandardFont,
                               standardFont.family())
        settings.setFontSize(QWebSettings.DefaultFontSize,
                             standardFont.pointSize())
        settings.setFontFamily(QWebSettings.FixedFont, fixedFont.family())
        settings.setFontSize(QWebSettings.DefaultFixedFontSize,
                             fixedFont.pointSize())
        
        styleSheet = Preferences.getHelp("UserStyleSheet")
        settings.setUserStyleSheetUrl(self.__userStyleSheet(styleSheet))
        
        settings.setAttribute(
            QWebSettings.AutoLoadImages,
            Preferences.getHelp("AutoLoadImages"))
        settings.setAttribute(
            QWebSettings.JavaEnabled,
            Preferences.getHelp("JavaEnabled"))
        settings.setAttribute(
            QWebSettings.JavascriptEnabled,
            Preferences.getHelp("JavaScriptEnabled"))
        settings.setAttribute(
            QWebSettings.JavascriptCanOpenWindows,
            Preferences.getHelp("JavaScriptCanOpenWindows"))
        settings.setAttribute(
            QWebSettings.JavascriptCanAccessClipboard,
            Preferences.getHelp("JavaScriptCanAccessClipboard"))
        settings.setAttribute(
            QWebSettings.PluginsEnabled,
            Preferences.getHelp("PluginsEnabled"))
        
        if hasattr(QWebSettings, "PrintElementBackgrounds"):
            settings.setAttribute(
                QWebSettings.PrintElementBackgrounds,
                Preferences.getHelp("PrintBackgrounds"))
        
        if hasattr(QWebSettings, "setOfflineStoragePath"):
            settings.setAttribute(
                QWebSettings.OfflineStorageDatabaseEnabled,
                Preferences.getHelp("OfflineStorageDatabaseEnabled"))
            webDatabaseDir = os.path.join(
                Utilities.getConfigDir(), "browser", "webdatabases")
            if not os.path.exists(webDatabaseDir):
                os.makedirs(webDatabaseDir)
            settings.setOfflineStoragePath(webDatabaseDir)
            settings.setOfflineStorageDefaultQuota(
                Preferences.getHelp("OfflineStorageDatabaseQuota") *
                1024 * 1024)
        
        if hasattr(QWebSettings, "OfflineWebApplicationCacheEnabled"):
            settings.setAttribute(
                QWebSettings.OfflineWebApplicationCacheEnabled,
                Preferences.getHelp("OfflineWebApplicationCacheEnabled"))
            appCacheDir = os.path.join(
                Utilities.getConfigDir(), "browser", "webappcaches")
            if not os.path.exists(appCacheDir):
                os.makedirs(appCacheDir)
            settings.setOfflineWebApplicationCachePath(appCacheDir)
            settings.setOfflineWebApplicationCacheQuota(
                Preferences.getHelp("OfflineWebApplicationCacheQuota") *
                1024 * 1024)
        
        if hasattr(QWebSettings, "LocalStorageEnabled"):
            settings.setAttribute(
                QWebSettings.LocalStorageEnabled,
                Preferences.getHelp("LocalStorageEnabled"))
            localStorageDir = os.path.join(
                Utilities.getConfigDir(), "browser", "weblocalstorage")
            if not os.path.exists(localStorageDir):
                os.makedirs(localStorageDir)
            settings.setLocalStoragePath(localStorageDir)
        
        if hasattr(QWebSettings, "DnsPrefetchEnabled"):
            settings.setAttribute(
                QWebSettings.DnsPrefetchEnabled,
                Preferences.getHelp("DnsPrefetchEnabled"))
        
        if hasattr(QWebSettings, "defaultTextEncoding"):
            settings.setDefaultTextEncoding(
                Preferences.getHelp("DefaultTextEncoding"))
        
        if hasattr(QWebSettings, "SpatialNavigationEnabled"):
            settings.setAttribute(
                QWebSettings.SpatialNavigationEnabled,
                Preferences.getHelp("SpatialNavigationEnabled"))
        if hasattr(QWebSettings, "LinksIncludedInFocusChain"):
            settings.setAttribute(
                QWebSettings.LinksIncludedInFocusChain,
                Preferences.getHelp("LinksIncludedInFocusChain"))
        if hasattr(QWebSettings, "LocalContentCanAccessRemoteUrls"):
            settings.setAttribute(
                QWebSettings.LocalContentCanAccessRemoteUrls,
                Preferences.getHelp("LocalContentCanAccessRemoteUrls"))
        if hasattr(QWebSettings, "LocalContentCanAccessFileUrls"):
            settings.setAttribute(
                QWebSettings.LocalContentCanAccessFileUrls,
                Preferences.getHelp("LocalContentCanAccessFileUrls"))
        if hasattr(QWebSettings, "XSSAuditingEnabled"):
            settings.setAttribute(
                QWebSettings.XSSAuditingEnabled,
                Preferences.getHelp("XSSAuditingEnabled"))
        if hasattr(QWebSettings, "SiteSpecificQuirksEnabled"):
            settings.setAttribute(
                QWebSettings.SiteSpecificQuirksEnabled,
                Preferences.getHelp("SiteSpecificQuirksEnabled"))
        
        QWebSecurityOrigin.addLocalScheme("eric")
    
    def __initActions(self):
        """
        Private method to define the user interface actions.
        """
        # list of all actions
        self.__actions = []
        
        self.newTabAct = E5Action(
            self.tr('New Tab'),
            UI.PixmapCache.getIcon("tabNew.png"),
            self.tr('&New Tab'),
            QKeySequence(self.tr("Ctrl+T", "File|New Tab")),
            0, self, 'help_file_new_tab')
        self.newTabAct.setStatusTip(self.tr('Open a new help window tab'))
        self.newTabAct.setWhatsThis(self.tr(
            """<b>New Tab</b>"""
            """<p>This opens a new help window tab.</p>"""
        ))
        self.newTabAct.triggered.connect(self.newTab)
        self.__actions.append(self.newTabAct)
        
        self.newAct = E5Action(
            self.tr('New Window'),
            UI.PixmapCache.getIcon("newWindow.png"),
            self.tr('New &Window'),
            QKeySequence(self.tr("Ctrl+N", "File|New Window")),
            0, self, 'help_file_new_window')
        self.newAct.setStatusTip(self.tr('Open a new help browser window'))
        self.newAct.setWhatsThis(self.tr(
            """<b>New Window</b>"""
            """<p>This opens a new help browser window.</p>"""
        ))
        self.newAct.triggered.connect(self.newWindow)
        self.__actions.append(self.newAct)
        
        self.openAct = E5Action(
            self.tr('Open File'),
            UI.PixmapCache.getIcon("open.png"),
            self.tr('&Open File'),
            QKeySequence(self.tr("Ctrl+O", "File|Open")),
            0, self, 'help_file_open')
        self.openAct.setStatusTip(self.tr('Open a help file for display'))
        self.openAct.setWhatsThis(self.tr(
            """<b>Open File</b>"""
            """<p>This opens a new help file for display."""
            """ It pops up a file selection dialog.</p>"""
        ))
        self.openAct.triggered.connect(self.__openFile)
        self.__actions.append(self.openAct)
        
        self.openTabAct = E5Action(
            self.tr('Open File in New Tab'),
            UI.PixmapCache.getIcon("openNewTab.png"),
            self.tr('Open File in New &Tab'),
            QKeySequence(self.tr("Shift+Ctrl+O", "File|Open in new tab")),
            0, self, 'help_file_open_tab')
        self.openTabAct.setStatusTip(
            self.tr('Open a help file for display in a new tab'))
        self.openTabAct.setWhatsThis(self.tr(
            """<b>Open File in New Tab</b>"""
            """<p>This opens a new help file for display in a new tab."""
            """ It pops up a file selection dialog.</p>"""
        ))
        self.openTabAct.triggered.connect(self.__openFileNewTab)
        self.__actions.append(self.openTabAct)
        
        self.saveAsAct = E5Action(
            self.tr('Save As'),
            UI.PixmapCache.getIcon("fileSaveAs.png"),
            self.tr('&Save As...'),
            QKeySequence(self.tr("Shift+Ctrl+S", "File|Save As")),
            0, self, 'help_file_save_as')
        self.saveAsAct.setStatusTip(
            self.tr('Save the current page to disk'))
        self.saveAsAct.setWhatsThis(self.tr(
            """<b>Save As...</b>"""
            """<p>Saves the current page to disk.</p>"""
        ))
        self.saveAsAct.triggered.connect(self.__savePageAs)
        self.__actions.append(self.saveAsAct)
        
        self.savePageScreenAct = E5Action(
            self.tr('Save Page Screen'),
            UI.PixmapCache.getIcon("fileSavePixmap.png"),
            self.tr('Save Page Screen...'),
            0, 0, self, 'help_file_save_page_screen')
        self.savePageScreenAct.setStatusTip(
            self.tr('Save the current page as a screen shot'))
        self.savePageScreenAct.setWhatsThis(self.tr(
            """<b>Save Page Screen...</b>"""
            """<p>Saves the current page as a screen shot.</p>"""
        ))
        self.savePageScreenAct.triggered.connect(self.__savePageScreen)
        self.__actions.append(self.savePageScreenAct)
        
        self.saveVisiblePageScreenAct = E5Action(
            self.tr('Save Visible Page Screen'),
            UI.PixmapCache.getIcon("fileSaveVisiblePixmap.png"),
            self.tr('Save Visible Page Screen...'),
            0, 0, self, 'help_file_save_visible_page_screen')
        self.saveVisiblePageScreenAct.setStatusTip(
            self.tr('Save the visible part of the current page as a'
                    ' screen shot'))
        self.saveVisiblePageScreenAct.setWhatsThis(self.tr(
            """<b>Save Visible Page Screen...</b>"""
            """<p>Saves the visible part of the current page as a"""
            """ screen shot.</p>"""
        ))
        self.saveVisiblePageScreenAct.triggered.connect(
            self.__saveVisiblePageScreen)
        self.__actions.append(self.saveVisiblePageScreenAct)
        
        bookmarksManager = self.bookmarksManager()
        self.importBookmarksAct = E5Action(
            self.tr('Import Bookmarks'),
            self.tr('&Import Bookmarks...'),
            0, 0, self, 'help_file_import_bookmarks')
        self.importBookmarksAct.setStatusTip(
            self.tr('Import bookmarks from other browsers'))
        self.importBookmarksAct.setWhatsThis(self.tr(
            """<b>Import Bookmarks</b>"""
            """<p>Import bookmarks from other browsers.</p>"""
        ))
        self.importBookmarksAct.triggered.connect(
            bookmarksManager.importBookmarks)
        self.__actions.append(self.importBookmarksAct)
        
        self.exportBookmarksAct = E5Action(
            self.tr('Export Bookmarks'),
            self.tr('&Export Bookmarks...'),
            0, 0, self, 'help_file_export_bookmarks')
        self.exportBookmarksAct.setStatusTip(
            self.tr('Export the bookmarks into a file'))
        self.exportBookmarksAct.setWhatsThis(self.tr(
            """<b>Export Bookmarks</b>"""
            """<p>Export the bookmarks into a file.</p>"""
        ))
        self.exportBookmarksAct.triggered.connect(
            bookmarksManager.exportBookmarks)
        self.__actions.append(self.exportBookmarksAct)
        
        self.printAct = E5Action(
            self.tr('Print'),
            UI.PixmapCache.getIcon("print.png"),
            self.tr('&Print'),
            QKeySequence(self.tr("Ctrl+P", "File|Print")),
            0, self, 'help_file_print')
        self.printAct.setStatusTip(self.tr('Print the displayed help'))
        self.printAct.setWhatsThis(self.tr(
            """<b>Print</b>"""
            """<p>Print the displayed help text.</p>"""
        ))
        self.printAct.triggered.connect(self.tabWidget.printBrowser)
        self.__actions.append(self.printAct)
        
        if Globals.isLinuxPlatform():
            self.printPdfAct = E5Action(
                self.tr('Print as PDF'),
                UI.PixmapCache.getIcon("printPdf.png"),
                self.tr('Print as PDF'),
                0, 0, self, 'help_file_print_pdf')
            self.printPdfAct.setStatusTip(self.tr(
                'Print the displayed help as PDF'))
            self.printPdfAct.setWhatsThis(self.tr(
                """<b>Print as PDF</b>"""
                """<p>Print the displayed help text as a PDF file.</p>"""
            ))
            self.printPdfAct.triggered.connect(
                self.tabWidget.printBrowserPdf)
            self.__actions.append(self.printPdfAct)
        else:
            self.printPdfAct = None
        
        self.printPreviewAct = E5Action(
            self.tr('Print Preview'),
            UI.PixmapCache.getIcon("printPreview.png"),
            self.tr('Print Preview'),
            0, 0, self, 'help_file_print_preview')
        self.printPreviewAct.setStatusTip(self.tr(
            'Print preview of the displayed help'))
        self.printPreviewAct.setWhatsThis(self.tr(
            """<b>Print Preview</b>"""
            """<p>Print preview of the displayed help text.</p>"""
        ))
        self.printPreviewAct.triggered.connect(
            self.tabWidget.printPreviewBrowser)
        self.__actions.append(self.printPreviewAct)
        
        self.closeAct = E5Action(
            self.tr('Close'),
            UI.PixmapCache.getIcon("close.png"),
            self.tr('&Close'),
            QKeySequence(self.tr("Ctrl+W", "File|Close")),
            0, self, 'help_file_close')
        self.closeAct.setStatusTip(self.tr(
            'Close the current help window'))
        self.closeAct.setWhatsThis(self.tr(
            """<b>Close</b>"""
            """<p>Closes the current help window.</p>"""
        ))
        self.closeAct.triggered.connect(self.tabWidget.closeBrowser)
        self.__actions.append(self.closeAct)
        
        self.closeAllAct = E5Action(
            self.tr('Close All'),
            self.tr('Close &All'),
            0, 0, self, 'help_file_close_all')
        self.closeAllAct.setStatusTip(self.tr('Close all help windows'))
        self.closeAllAct.setWhatsThis(self.tr(
            """<b>Close All</b>"""
            """<p>Closes all help windows except the first one.</p>"""
        ))
        self.closeAllAct.triggered.connect(
            self.tabWidget.closeAllBrowsers)
        self.__actions.append(self.closeAllAct)
        
        self.privateBrowsingAct = E5Action(
            self.tr('Private Browsing'),
            UI.PixmapCache.getIcon("privateBrowsing.png"),
            self.tr('Private &Browsing'),
            0, 0, self, 'help_file_private_browsing')
        self.privateBrowsingAct.setStatusTip(self.tr('Private Browsing'))
        self.privateBrowsingAct.setWhatsThis(self.tr(
            """<b>Private Browsing</b>"""
            """<p>Enables private browsing. In this mode no history is"""
            """ recorded anymore.</p>"""
        ))
        self.privateBrowsingAct.triggered.connect(
            self.__privateBrowsing)
        self.privateBrowsingAct.setCheckable(True)
        self.__actions.append(self.privateBrowsingAct)
        
        self.exitAct = E5Action(
            self.tr('Quit'),
            UI.PixmapCache.getIcon("exit.png"),
            self.tr('&Quit'),
            QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
            0, self, 'help_file_quit')
        self.exitAct.setStatusTip(self.tr('Quit the eric6 Web Browser'))
        self.exitAct.setWhatsThis(self.tr(
            """<b>Quit</b>"""
            """<p>Quit the eric6 Web Browser.</p>"""
        ))
        self.exitAct.triggered.connect(self.__closeAllWindows)
        self.__actions.append(self.exitAct)
        
        self.backAct = E5Action(
            self.tr('Backward'),
            UI.PixmapCache.getIcon("back.png"),
            self.tr('&Backward'),
            QKeySequence(self.tr("Alt+Left", "Go|Backward")),
            QKeySequence(self.tr("Backspace", "Go|Backward")),
            self, 'help_go_backward')
        self.backAct.setStatusTip(self.tr('Move one help screen backward'))
        self.backAct.setWhatsThis(self.tr(
            """<b>Backward</b>"""
            """<p>Moves one help screen backward. If none is"""
            """ available, this action is disabled.</p>"""
        ))
        self.backAct.triggered.connect(self.__backward)
        self.__actions.append(self.backAct)
        
        self.forwardAct = E5Action(
            self.tr('Forward'),
            UI.PixmapCache.getIcon("forward.png"),
            self.tr('&Forward'),
            QKeySequence(self.tr("Alt+Right", "Go|Forward")),
            QKeySequence(self.tr("Shift+Backspace", "Go|Forward")),
            self, 'help_go_foreward')
        self.forwardAct.setStatusTip(self.tr(
            'Move one help screen forward'))
        self.forwardAct.setWhatsThis(self.tr(
            """<b>Forward</b>"""
            """<p>Moves one help screen forward. If none is"""
            """ available, this action is disabled.</p>"""
        ))
        self.forwardAct.triggered.connect(self.__forward)
        self.__actions.append(self.forwardAct)
        
        self.homeAct = E5Action(
            self.tr('Home'),
            UI.PixmapCache.getIcon("home.png"),
            self.tr('&Home'),
            QKeySequence(self.tr("Ctrl+Home", "Go|Home")),
            0, self, 'help_go_home')
        self.homeAct.setStatusTip(self.tr(
            'Move to the initial help screen'))
        self.homeAct.setWhatsThis(self.tr(
            """<b>Home</b>"""
            """<p>Moves to the initial help screen.</p>"""
        ))
        self.homeAct.triggered.connect(self.__home)
        self.__actions.append(self.homeAct)
        
        self.reloadAct = E5Action(
            self.tr('Reload'),
            UI.PixmapCache.getIcon("reload.png"),
            self.tr('&Reload'),
            QKeySequence(self.tr("Ctrl+R", "Go|Reload")),
            QKeySequence(self.tr("F5", "Go|Reload")),
            self, 'help_go_reload')
        self.reloadAct.setStatusTip(self.tr(
            'Reload the current help screen'))
        self.reloadAct.setWhatsThis(self.tr(
            """<b>Reload</b>"""
            """<p>Reloads the current help screen.</p>"""
        ))
        self.reloadAct.triggered.connect(self.__reload)
        self.__actions.append(self.reloadAct)
        
        self.stopAct = E5Action(
            self.tr('Stop'),
            UI.PixmapCache.getIcon("stopLoading.png"),
            self.tr('&Stop'),
            QKeySequence(self.tr("Ctrl+.", "Go|Stop")),
            QKeySequence(self.tr("Esc", "Go|Stop")),
            self, 'help_go_stop')
        self.stopAct.setStatusTip(self.tr('Stop loading'))
        self.stopAct.setWhatsThis(self.tr(
            """<b>Stop</b>"""
            """<p>Stops loading of the current tab.</p>"""
        ))
        self.stopAct.triggered.connect(self.__stopLoading)
        self.__actions.append(self.stopAct)
        
        self.copyAct = E5Action(
            self.tr('Copy'),
            UI.PixmapCache.getIcon("editCopy.png"),
            self.tr('&Copy'),
            QKeySequence(self.tr("Ctrl+C", "Edit|Copy")),
            0, self, 'help_edit_copy')
        self.copyAct.setStatusTip(self.tr('Copy the selected text'))
        self.copyAct.setWhatsThis(self.tr(
            """<b>Copy</b>"""
            """<p>Copy the selected text to the clipboard.</p>"""
        ))
        self.copyAct.triggered.connect(self.__copy)
        self.__actions.append(self.copyAct)
        
        self.findAct = E5Action(
            self.tr('Find...'),
            UI.PixmapCache.getIcon("find.png"),
            self.tr('&Find...'),
            QKeySequence(self.tr("Ctrl+F", "Edit|Find")),
            0, self, 'help_edit_find')
        self.findAct.setStatusTip(self.tr('Find text in page'))
        self.findAct.setWhatsThis(self.tr(
            """<b>Find</b>"""
            """<p>Find text in the current page.</p>"""
        ))
        self.findAct.triggered.connect(self.__find)
        self.__actions.append(self.findAct)
        
        self.findNextAct = E5Action(
            self.tr('Find next'),
            UI.PixmapCache.getIcon("findNext.png"),
            self.tr('Find &next'),
            QKeySequence(self.tr("F3", "Edit|Find next")),
            0, self, 'help_edit_find_next')
        self.findNextAct.setStatusTip(self.tr(
            'Find next occurrence of text in page'))
        self.findNextAct.setWhatsThis(self.tr(
            """<b>Find next</b>"""
            """<p>Find the next occurrence of text in the current page.</p>"""
        ))
        self.findNextAct.triggered.connect(self.findDlg.findNext)
        self.__actions.append(self.findNextAct)
        
        self.findPrevAct = E5Action(
            self.tr('Find previous'),
            UI.PixmapCache.getIcon("findPrev.png"),
            self.tr('Find &previous'),
            QKeySequence(self.tr("Shift+F3", "Edit|Find previous")),
            0, self, 'help_edit_find_previous')
        self.findPrevAct.setStatusTip(
            self.tr('Find previous occurrence of text in page'))
        self.findPrevAct.setWhatsThis(self.tr(
            """<b>Find previous</b>"""
            """<p>Find the previous occurrence of text in the current"""
            """ page.</p>"""
        ))
        self.findPrevAct.triggered.connect(self.findDlg.findPrevious)
        self.__actions.append(self.findPrevAct)
        
        self.bookmarksManageAct = E5Action(
            self.tr('Manage Bookmarks'),
            self.tr('&Manage Bookmarks...'),
            QKeySequence(self.tr("Ctrl+Shift+B", "Help|Manage bookmarks")),
            0, self, 'help_bookmarks_manage')
        self.bookmarksManageAct.setStatusTip(self.tr(
            'Open a dialog to manage the bookmarks.'))
        self.bookmarksManageAct.setWhatsThis(self.tr(
            """<b>Manage Bookmarks...</b>"""
            """<p>Open a dialog to manage the bookmarks.</p>"""
        ))
        self.bookmarksManageAct.triggered.connect(
            self.__showBookmarksDialog)
        self.__actions.append(self.bookmarksManageAct)
        
        self.bookmarksAddAct = E5Action(
            self.tr('Add Bookmark'),
            UI.PixmapCache.getIcon("addBookmark.png"),
            self.tr('Add &Bookmark...'),
            QKeySequence(self.tr("Ctrl+D", "Help|Add bookmark")),
            0, self, 'help_bookmark_add')
        self.bookmarksAddAct.setIconVisibleInMenu(False)
        self.bookmarksAddAct.setStatusTip(self.tr(
            'Open a dialog to add a bookmark.'))
        self.bookmarksAddAct.setWhatsThis(self.tr(
            """<b>Add Bookmark</b>"""
            """<p>Open a dialog to add the current URL as a bookmark.</p>"""
        ))
        self.bookmarksAddAct.triggered.connect(self.__addBookmark)
        self.__actions.append(self.bookmarksAddAct)
        
        self.bookmarksAddFolderAct = E5Action(
            self.tr('Add Folder'),
            self.tr('Add &Folder...'),
            0, 0, self, 'help_bookmark_show_all')
        self.bookmarksAddFolderAct.setStatusTip(self.tr(
            'Open a dialog to add a new bookmarks folder.'))
        self.bookmarksAddFolderAct.setWhatsThis(self.tr(
            """<b>Add Folder...</b>"""
            """<p>Open a dialog to add a new bookmarks folder.</p>"""
        ))
        self.bookmarksAddFolderAct.triggered.connect(
            self.__addBookmarkFolder)
        self.__actions.append(self.bookmarksAddFolderAct)
        
        self.bookmarksAllTabsAct = E5Action(
            self.tr('Bookmark All Tabs'),
            self.tr('Bookmark All Tabs...'),
            0, 0, self, 'help_bookmark_all_tabs')
        self.bookmarksAllTabsAct.setStatusTip(self.tr(
            'Bookmark all open tabs.'))
        self.bookmarksAllTabsAct.setWhatsThis(self.tr(
            """<b>Bookmark All Tabs...</b>"""
            """<p>Open a dialog to add a new bookmarks folder for"""
            """ all open tabs.</p>"""
        ))
        self.bookmarksAllTabsAct.triggered.connect(self.bookmarkAll)
        self.__actions.append(self.bookmarksAllTabsAct)
        
        self.whatsThisAct = E5Action(
            self.tr('What\'s This?'),
            UI.PixmapCache.getIcon("whatsThis.png"),
            self.tr('&What\'s This?'),
            QKeySequence(self.tr("Shift+F1", "Help|What's This?'")),
            0, self, 'help_help_whats_this')
        self.whatsThisAct.setStatusTip(self.tr('Context sensitive help'))
        self.whatsThisAct.setWhatsThis(self.tr(
            """<b>Display context sensitive help</b>"""
            """<p>In What's This? mode, the mouse cursor shows an arrow"""
            """ with a question mark, and you can click on the interface"""
            """ elements to get a short description of what they do and how"""
            """ to use them. In dialogs, this feature can be accessed using"""
            """ the context help button in the titlebar.</p>"""
        ))
        self.whatsThisAct.triggered.connect(self.__whatsThis)
        self.__actions.append(self.whatsThisAct)
        
        self.aboutAct = E5Action(
            self.tr('About'),
            self.tr('&About'),
            0, 0, self, 'help_help_about')
        self.aboutAct.setStatusTip(self.tr(
            'Display information about this software'))
        self.aboutAct.setWhatsThis(self.tr(
            """<b>About</b>"""
            """<p>Display some information about this software.</p>"""
        ))
        self.aboutAct.triggered.connect(self.__about)
        self.__actions.append(self.aboutAct)
        
        self.aboutQtAct = E5Action(
            self.tr('About Qt'),
            self.tr('About &Qt'),
            0, 0, self, 'help_help_about_qt')
        self.aboutQtAct.setStatusTip(
            self.tr('Display information about the Qt toolkit'))
        self.aboutQtAct.setWhatsThis(self.tr(
            """<b>About Qt</b>"""
            """<p>Display some information about the Qt toolkit.</p>"""
        ))
        self.aboutQtAct.triggered.connect(self.__aboutQt)
        self.__actions.append(self.aboutQtAct)
        
        self.zoomInAct = E5Action(
            self.tr('Zoom in'),
            UI.PixmapCache.getIcon("zoomIn.png"),
            self.tr('Zoom &in'),
            QKeySequence(self.tr("Ctrl++", "View|Zoom in")),
            QKeySequence(self.tr("Zoom In", "View|Zoom in")),
            self, 'help_view_zoom_in')
        self.zoomInAct.setStatusTip(self.tr('Zoom in on the text'))
        self.zoomInAct.setWhatsThis(self.tr(
            """<b>Zoom in</b>"""
            """<p>Zoom in on the text. This makes the text bigger.</p>"""
        ))
        self.zoomInAct.triggered.connect(self.__zoomIn)
        self.__actions.append(self.zoomInAct)
        
        self.zoomOutAct = E5Action(
            self.tr('Zoom out'),
            UI.PixmapCache.getIcon("zoomOut.png"),
            self.tr('Zoom &out'),
            QKeySequence(self.tr("Ctrl+-", "View|Zoom out")),
            QKeySequence(self.tr("Zoom Out", "View|Zoom out")),
            self, 'help_view_zoom_out')
        self.zoomOutAct.setStatusTip(self.tr('Zoom out on the text'))
        self.zoomOutAct.setWhatsThis(self.tr(
            """<b>Zoom out</b>"""
            """<p>Zoom out on the text. This makes the text smaller.</p>"""
        ))
        self.zoomOutAct.triggered.connect(self.__zoomOut)
        self.__actions.append(self.zoomOutAct)
        
        self.zoomResetAct = E5Action(
            self.tr('Zoom reset'),
            UI.PixmapCache.getIcon("zoomReset.png"),
            self.tr('Zoom &reset'),
            QKeySequence(self.tr("Ctrl+0", "View|Zoom reset")),
            0, self, 'help_view_zoom_reset')
        self.zoomResetAct.setStatusTip(self.tr(
            'Reset the zoom of the text'))
        self.zoomResetAct.setWhatsThis(self.tr(
            """<b>Zoom reset</b>"""
            """<p>Reset the zoom of the text. """
            """This sets the zoom factor to 100%.</p>"""
        ))
        self.zoomResetAct.triggered.connect(self.__zoomReset)
        self.__actions.append(self.zoomResetAct)
        
        if hasattr(QWebSettings, 'ZoomTextOnly'):
            self.zoomTextOnlyAct = E5Action(
                self.tr('Zoom text only'),
                self.tr('Zoom &text only'),
                0, 0, self, 'help_view_zoom_text_only')
            self.zoomTextOnlyAct.setCheckable(True)
            self.zoomTextOnlyAct.setStatusTip(self.tr(
                'Zoom text only; pictures remain constant'))
            self.zoomTextOnlyAct.setWhatsThis(self.tr(
                """<b>Zoom text only</b>"""
                """<p>Zoom text only; pictures remain constant.</p>"""
            ))
            self.zoomTextOnlyAct.triggered[bool].connect(
                self.__zoomTextOnly)
            self.__actions.append(self.zoomTextOnlyAct)
        else:
            self.zoomTextOnlyAct = None
        
        self.pageSourceAct = E5Action(
            self.tr('Show page source'),
            self.tr('Show page source'),
            QKeySequence(self.tr('Ctrl+U')), 0,
            self, 'help_show_page_source')
        self.pageSourceAct.setStatusTip(self.tr(
            'Show the page source in an editor'))
        self.pageSourceAct.setWhatsThis(self.tr(
            """<b>Show page source</b>"""
            """<p>Show the page source in an editor.</p>"""
        ))
        self.pageSourceAct.triggered.connect(self.__showPageSource)
        self.__actions.append(self.pageSourceAct)
        self.addAction(self.pageSourceAct)
        
        self.fullScreenAct = E5Action(
            self.tr('Full Screen'),
            UI.PixmapCache.getIcon("windowFullscreen.png"),
            self.tr('&Full Screen'),
            QKeySequence(self.tr('F11')), 0,
            self, 'help_view_full_scree')
        self.fullScreenAct.triggered.connect(self.__viewFullScreen)
        self.__actions.append(self.fullScreenAct)
        self.addAction(self.fullScreenAct)
        
        self.nextTabAct = E5Action(
            self.tr('Show next tab'),
            self.tr('Show next tab'),
            QKeySequence(self.tr('Ctrl+Alt+Tab')), 0,
            self, 'help_view_next_tab')
        self.nextTabAct.triggered.connect(self.__nextTab)
        self.__actions.append(self.nextTabAct)
        self.addAction(self.nextTabAct)
        
        self.prevTabAct = E5Action(
            self.tr('Show previous tab'),
            self.tr('Show previous tab'),
            QKeySequence(self.tr('Shift+Ctrl+Alt+Tab')), 0,
            self, 'help_view_previous_tab')
        self.prevTabAct.triggered.connect(self.__prevTab)
        self.__actions.append(self.prevTabAct)
        self.addAction(self.prevTabAct)
        
        self.switchTabAct = E5Action(
            self.tr('Switch between tabs'),
            self.tr('Switch between tabs'),
            QKeySequence(self.tr('Ctrl+1')), 0,
            self, 'help_switch_tabs')
        self.switchTabAct.triggered.connect(self.__switchTab)
        self.__actions.append(self.switchTabAct)
        self.addAction(self.switchTabAct)
        
        self.prefAct = E5Action(
            self.tr('Preferences'),
            UI.PixmapCache.getIcon("configure.png"),
            self.tr('&Preferences...'), 0, 0, self, 'help_preferences')
        self.prefAct.setStatusTip(self.tr(
            'Set the prefered configuration'))
        self.prefAct.setWhatsThis(self.tr(
            """<b>Preferences</b>"""
            """<p>Set the configuration items of the application"""
            """ with your prefered values.</p>"""
        ))
        self.prefAct.triggered.connect(self.__showPreferences)
        self.__actions.append(self.prefAct)

        self.acceptedLanguagesAct = E5Action(
            self.tr('Languages'),
            UI.PixmapCache.getIcon("flag.png"),
            self.tr('&Languages...'), 0, 0,
            self, 'help_accepted_languages')
        self.acceptedLanguagesAct.setStatusTip(self.tr(
            'Configure the accepted languages for web pages'))
        self.acceptedLanguagesAct.setWhatsThis(self.tr(
            """<b>Languages</b>"""
            """<p>Configure the accepted languages for web pages.</p>"""
        ))
        self.acceptedLanguagesAct.triggered.connect(
            self.__showAcceptedLanguages)
        self.__actions.append(self.acceptedLanguagesAct)
        
        self.cookiesAct = E5Action(
            self.tr('Cookies'),
            UI.PixmapCache.getIcon("cookie.png"),
            self.tr('C&ookies...'), 0, 0, self, 'help_cookies')
        self.cookiesAct.setStatusTip(self.tr(
            'Configure cookies handling'))
        self.cookiesAct.setWhatsThis(self.tr(
            """<b>Cookies</b>"""
            """<p>Configure cookies handling.</p>"""
        ))
        self.cookiesAct.triggered.connect(
            self.__showCookiesConfiguration)
        self.__actions.append(self.cookiesAct)
        
        self.flashCookiesAct = E5Action(
            self.tr('Flash Cookies'),
            UI.PixmapCache.getIcon("flashCookie.png"),
            self.tr('&Flash Cookies...'), 0, 0, self, 'help_flash_cookies')
        self.flashCookiesAct.setStatusTip(self.tr(
            'Manage flash cookies'))
        self.flashCookiesAct.setWhatsThis(self.tr(
            """<b>Flash Cookies</b>"""
            """<p>Show a dialog to manage the flash cookies.</p>"""
        ))
        self.flashCookiesAct.triggered.connect(
            self.__showFlashCookiesManagement)
        self.__actions.append(self.flashCookiesAct)
        
        self.offlineStorageAct = E5Action(
            self.tr('Offline Storage'),
            UI.PixmapCache.getIcon("preferences-html5.png"),
            self.tr('Offline &Storage...'), 0, 0,
            self, 'help_offline_storage')
        self.offlineStorageAct.setStatusTip(self.tr(
            'Configure offline storage'))
        self.offlineStorageAct.setWhatsThis(self.tr(
            """<b>Offline Storage</b>"""
            """<p>Opens a dialog to configure offline storage.</p>"""
        ))
        self.offlineStorageAct.triggered.connect(
            self.__showOfflineStorageConfiguration)
        self.__actions.append(self.offlineStorageAct)
        
        self.personalDataAct = E5Action(
            self.tr('Personal Information'),
            UI.PixmapCache.getIcon("pim.png"),
            self.tr('Personal Information...'),
            0, 0,
            self, 'help_personal_information')
        self.personalDataAct.setStatusTip(self.tr(
            'Configure personal information for completing form fields'))
        self.personalDataAct.setWhatsThis(self.tr(
            """<b>Personal Information...</b>"""
            """<p>Opens a dialog to configure the personal information"""
            """ used for completing form fields.</p>"""
        ))
        self.personalDataAct.triggered.connect(
            self.__showPersonalInformationDialog)
        self.__actions.append(self.personalDataAct)
        
        self.greaseMonkeyAct = E5Action(
            self.tr('GreaseMonkey Scripts'),
            UI.PixmapCache.getIcon("greaseMonkey.png"),
            self.tr('GreaseMonkey Scripts...'),
            0, 0,
            self, 'help_greasemonkey')
        self.greaseMonkeyAct.setStatusTip(self.tr(
            'Configure the GreaseMonkey Scripts'))
        self.greaseMonkeyAct.setWhatsThis(self.tr(
            """<b>GreaseMonkey Scripts...</b>"""
            """<p>Opens a dialog to configure the available GreaseMonkey"""
            """ Scripts.</p>"""
        ))
        self.greaseMonkeyAct.triggered.connect(
            self.__showGreaseMonkeyConfigDialog)
        self.__actions.append(self.greaseMonkeyAct)
        
        self.editMessageFilterAct = E5Action(
            self.tr('Edit Message Filters'),
            UI.PixmapCache.getIcon("warning.png"),
            self.tr('Edit Message Filters...'), 0, 0, self,
            'help_manage_message_filters')
        self.editMessageFilterAct.setStatusTip(self.tr(
            'Edit the message filters used to suppress unwanted messages'))
        self.editMessageFilterAct.setWhatsThis(self.tr(
            """<b>Edit Message Filters</b>"""
            """<p>Opens a dialog to edit the message filters used to"""
            """ suppress unwanted messages been shown in an error"""
            """ window.</p>"""
        ))
        self.editMessageFilterAct.triggered.connect(
            E5ErrorMessage.editMessageFilters)
        self.__actions.append(self.editMessageFilterAct)

        self.featurePermissionAct = E5Action(
            self.tr('Edit HTML5 Feature Permissions'),
            UI.PixmapCache.getIcon("featurePermission.png"),
            self.tr('Edit HTML5 Feature Permissions...'), 0, 0, self,
            'help_edit_feature_permissions')
        self.featurePermissionAct.setStatusTip(self.tr(
            'Edit the remembered HTML5 feature permissions'))
        self.featurePermissionAct.setWhatsThis(self.tr(
            """<b>Edit HTML5 Feature Permissions</b>"""
            """<p>Opens a dialog to edit the remembered HTML5"""
            """ feature permissions.</p>"""
        ))
        self.featurePermissionAct.triggered.connect(
            self.__showFeaturePermissionDialog)
        self.__actions.append(self.featurePermissionAct)

        if HelpWindow._useQtHelp:
            self.syncTocAct = E5Action(
                self.tr('Sync with Table of Contents'),
                UI.PixmapCache.getIcon("syncToc.png"),
                self.tr('Sync with Table of Contents'),
                0, 0, self, 'help_sync_toc')
            self.syncTocAct.setStatusTip(self.tr(
                'Synchronizes the table of contents with current page'))
            self.syncTocAct.setWhatsThis(self.tr(
                """<b>Sync with Table of Contents</b>"""
                """<p>Synchronizes the table of contents with current"""
                """ page.</p>"""
            ))
            self.syncTocAct.triggered.connect(self.__syncTOC)
            self.__actions.append(self.syncTocAct)
            
            self.showTocAct = E5Action(
                self.tr('Table of Contents'),
                self.tr('Table of Contents'),
                0, 0, self, 'help_show_toc')
            self.showTocAct.setStatusTip(self.tr(
                'Shows the table of contents window'))
            self.showTocAct.setWhatsThis(self.tr(
                """<b>Table of Contents</b>"""
                """<p>Shows the table of contents window.</p>"""
            ))
            self.showTocAct.triggered.connect(self.__showTocWindow)
            self.__actions.append(self.showTocAct)
            
            self.showIndexAct = E5Action(
                self.tr('Index'),
                self.tr('Index'),
                0, 0, self, 'help_show_index')
            self.showIndexAct.setStatusTip(self.tr(
                'Shows the index window'))
            self.showIndexAct.setWhatsThis(self.tr(
                """<b>Index</b>"""
                """<p>Shows the index window.</p>"""
            ))
            self.showIndexAct.triggered.connect(self.__showIndexWindow)
            self.__actions.append(self.showIndexAct)
            
            self.showSearchAct = E5Action(
                self.tr('Search'),
                self.tr('Search'),
                0, 0, self, 'help_show_search')
            self.showSearchAct.setStatusTip(self.tr(
                'Shows the search window'))
            self.showSearchAct.setWhatsThis(self.tr(
                """<b>Search</b>"""
                """<p>Shows the search window.</p>"""
            ))
            self.showSearchAct.triggered.connect(
                self.__showSearchWindow)
            self.__actions.append(self.showSearchAct)
            
            self.manageQtHelpDocsAct = E5Action(
                self.tr('Manage QtHelp Documents'),
                self.tr('Manage QtHelp &Documents'),
                0, 0, self, 'help_qthelp_documents')
            self.manageQtHelpDocsAct.setStatusTip(self.tr(
                'Shows a dialog to manage the QtHelp documentation set'))
            self.manageQtHelpDocsAct.setWhatsThis(self.tr(
                """<b>Manage QtHelp Documents</b>"""
                """<p>Shows a dialog to manage the QtHelp documentation"""
                """ set.</p>"""
            ))
            self.manageQtHelpDocsAct.triggered.connect(
                self.__manageQtHelpDocumentation)
            self.__actions.append(self.manageQtHelpDocsAct)
            
            self.manageQtHelpFiltersAct = E5Action(
                self.tr('Manage QtHelp Filters'),
                self.tr('Manage QtHelp &Filters'),
                0, 0, self, 'help_qthelp_filters')
            self.manageQtHelpFiltersAct.setStatusTip(self.tr(
                'Shows a dialog to manage the QtHelp filters'))
            self.manageQtHelpFiltersAct.setWhatsThis(self.tr(
                """<b>Manage QtHelp Filters</b>"""
                """<p>Shows a dialog to manage the QtHelp filters.</p>"""
            ))
            self.manageQtHelpFiltersAct.triggered.connect(
                self.__manageQtHelpFilters)
            self.__actions.append(self.manageQtHelpFiltersAct)
            
            self.reindexDocumentationAct = E5Action(
                self.tr('Reindex Documentation'),
                self.tr('&Reindex Documentation'),
                0, 0, self, 'help_qthelp_reindex')
            self.reindexDocumentationAct.setStatusTip(self.tr(
                'Reindexes the documentation set'))
            self.reindexDocumentationAct.setWhatsThis(self.tr(
                """<b>Reindex Documentation</b>"""
                """<p>Reindexes the documentation set.</p>"""
            ))
            self.reindexDocumentationAct.triggered.connect(
                self.__searchEngine.reindexDocumentation)
            self.__actions.append(self.reindexDocumentationAct)
        
        self.clearPrivateDataAct = E5Action(
            self.tr('Clear private data'),
            UI.PixmapCache.getIcon("clearPrivateData.png"),
            self.tr('Clear private data'),
            0, 0,
            self, 'help_clear_private_data')
        self.clearPrivateDataAct.setStatusTip(self.tr(
            'Clear private data'))
        self.clearPrivateDataAct.setWhatsThis(self.tr(
            """<b>Clear private data</b>"""
            """<p>Clears the private data like browsing history, search"""
            """ history or the favicons database.</p>"""
        ))
        self.clearPrivateDataAct.triggered.connect(
            self.__clearPrivateData)
        self.__actions.append(self.clearPrivateDataAct)
        
        self.clearIconsAct = E5Action(
            self.tr('Clear icons database'),
            self.tr('Clear &icons database'),
            0, 0,
            self, 'help_clear_icons_db')
        self.clearIconsAct.setStatusTip(self.tr(
            'Clear the database of favicons'))
        self.clearIconsAct.setWhatsThis(self.tr(
            """<b>Clear icons database</b>"""
            """<p>Clears the database of favicons of previously visited"""
            """ URLs.</p>"""
        ))
        self.clearIconsAct.triggered.connect(self.__clearIconsDatabase)
        self.__actions.append(self.clearIconsAct)
        
        self.searchEnginesAct = E5Action(
            self.tr('Configure Search Engines'),
            self.tr('Configure Search &Engines...'),
            0, 0,
            self, 'help_search_engines')
        self.searchEnginesAct.setStatusTip(self.tr(
            'Configure the available search engines'))
        self.searchEnginesAct.setWhatsThis(self.tr(
            """<b>Configure Search Engines...</b>"""
            """<p>Opens a dialog to configure the available search"""
            """ engines.</p>"""
        ))
        self.searchEnginesAct.triggered.connect(
            self.__showEnginesConfigurationDialog)
        self.__actions.append(self.searchEnginesAct)
        
        self.passwordsAct = E5Action(
            self.tr('Manage Saved Passwords'),
            UI.PixmapCache.getIcon("passwords.png"),
            self.tr('Manage Saved Passwords...'),
            0, 0,
            self, 'help_manage_passwords')
        self.passwordsAct.setStatusTip(self.tr(
            'Manage the saved passwords'))
        self.passwordsAct.setWhatsThis(self.tr(
            """<b>Manage Saved Passwords...</b>"""
            """<p>Opens a dialog to manage the saved passwords.</p>"""
        ))
        self.passwordsAct.triggered.connect(self.__showPasswordsDialog)
        self.__actions.append(self.passwordsAct)
        
        self.adblockAct = E5Action(
            self.tr('Ad Block'),
            UI.PixmapCache.getIcon("adBlockPlus.png"),
            self.tr('&Ad Block...'),
            0, 0,
            self, 'help_adblock')
        self.adblockAct.setStatusTip(self.tr(
            'Configure AdBlock subscriptions and rules'))
        self.adblockAct.setWhatsThis(self.tr(
            """<b>Ad Block...</b>"""
            """<p>Opens a dialog to configure AdBlock subscriptions and"""
            """ rules.</p>"""
        ))
        self.adblockAct.triggered.connect(self.__showAdBlockDialog)
        self.__actions.append(self.adblockAct)
        
        self.flashblockAct = E5Action(
            self.tr('ClickToFlash'),
            UI.PixmapCache.getIcon("flashBlock.png"),
            self.tr('&ClickToFlash...'),
            0, 0,
            self, 'help_flashblock')
        self.flashblockAct.setStatusTip(self.tr(
            'Configure ClickToFlash whitelist'))
        self.flashblockAct.setWhatsThis(self.tr(
            """<b>ClickToFlash...</b>"""
            """<p>Opens a dialog to configure the ClickToFlash"""
            """ whitelist.</p>"""
        ))
        self.flashblockAct.triggered.connect(
            self.__showClickToFlashDialog)
        self.__actions.append(self.flashblockAct)
        
        if SSL_AVAILABLE:
            self.certificatesAct = E5Action(
                self.tr('Manage SSL Certificates'),
                UI.PixmapCache.getIcon("certificates.png"),
                self.tr('Manage SSL Certificates...'),
                0, 0,
                self, 'help_manage_certificates')
            self.certificatesAct.setStatusTip(self.tr(
                'Manage the saved SSL certificates'))
            self.certificatesAct.setWhatsThis(self.tr(
                """<b>Manage SSL Certificates...</b>"""
                """<p>Opens a dialog to manage the saved SSL"""
                """ certificates.</p>"""
            ))
            self.certificatesAct.triggered.connect(
                self.__showCertificatesDialog)
            self.__actions.append(self.certificatesAct)
        
        self.toolsMonitorAct = E5Action(
            self.tr('Network Monitor'),
            self.tr('&Network Monitor...'),
            0, 0,
            self, 'help_tools_network_monitor')
        self.toolsMonitorAct.setStatusTip(self.tr(
            'Show the network monitor dialog'))
        self.toolsMonitorAct.setWhatsThis(self.tr(
            """<b>Network Monitor...</b>"""
            """<p>Shows the network monitor dialog.</p>"""
        ))
        self.toolsMonitorAct.triggered.connect(
            self.__showNetworkMonitor)
        self.__actions.append(self.toolsMonitorAct)
        
        self.showDownloadManagerAct = E5Action(
            self.tr('Downloads'),
            self.tr('Downloads'),
            0, 0, self, 'help_show_downloads')
        self.showDownloadManagerAct.setStatusTip(self.tr(
            'Shows the downloads window'))
        self.showDownloadManagerAct.setWhatsThis(self.tr(
            """<b>Downloads</b>"""
            """<p>Shows the downloads window.</p>"""
        ))
        self.showDownloadManagerAct.triggered.connect(
            self.__showDownloadsWindow)
        self.__actions.append(self.showDownloadManagerAct)
        
        self.feedsManagerAct = E5Action(
            self.tr('RSS Feeds Dialog'),
            UI.PixmapCache.getIcon("rss22.png"),
            self.tr('&RSS Feeds Dialog...'),
            QKeySequence(self.tr("Ctrl+Shift+F", "Help|RSS Feeds Dialog")),
            0, self, 'help_rss_feeds')
        self.feedsManagerAct.setStatusTip(self.tr(
            'Open a dialog showing the configured RSS feeds.'))
        self.feedsManagerAct.setWhatsThis(self.tr(
            """<b>RSS Feeds Dialog...</b>"""
            """<p>Open a dialog to show the configured RSS feeds."""
            """ It can be used to mange the feeds and to show their"""
            """ contents.</p>"""
        ))
        self.feedsManagerAct.triggered.connect(self.__showFeedsManager)
        self.__actions.append(self.feedsManagerAct)
        
        self.siteInfoAct = E5Action(
            self.tr('Siteinfo Dialog'),
            UI.PixmapCache.getIcon("helpAbout.png"),
            self.tr('&Siteinfo Dialog...'),
            QKeySequence(self.tr("Ctrl+Shift+I", "Help|Siteinfo Dialog")),
            0, self, 'help_siteinfo')
        self.siteInfoAct.setStatusTip(self.tr(
            'Open a dialog showing some information about the current site.'))
        self.siteInfoAct.setWhatsThis(self.tr(
            """<b>Siteinfo Dialog...</b>"""
            """<p>Opens a dialog showing some information about the current"""
            """ site.</p>"""
        ))
        self.siteInfoAct.triggered.connect(self.__showSiteinfoDialog)
        self.__actions.append(self.siteInfoAct)
        
        self.userAgentManagerAct = E5Action(
            self.tr('Manage User Agent Settings'),
            self.tr('Manage &User Agent Settings'),
            0, 0, self, 'help_user_agent_settings')
        self.userAgentManagerAct.setStatusTip(self.tr(
            'Shows a dialog to manage the User Agent settings'))
        self.userAgentManagerAct.setWhatsThis(self.tr(
            """<b>Manage User Agent Settings</b>"""
            """<p>Shows a dialog to manage the User Agent settings.</p>"""
        ))
        self.userAgentManagerAct.triggered.connect(
            self.__showUserAgentsDialog)
        self.__actions.append(self.userAgentManagerAct)
        
        self.synchronizationAct = E5Action(
            self.tr('Synchronize data'),
            UI.PixmapCache.getIcon("sync.png"),
            self.tr('&Synchronize Data...'),
            0, 0, self, 'help_synchronize_data')
        self.synchronizationAct.setStatusTip(self.tr(
            'Shows a dialog to synchronize data via the network'))
        self.synchronizationAct.setWhatsThis(self.tr(
            """<b>Synchronize Data...</b>"""
            """<p>This shows a dialog to synchronize data via the"""
            """ network.</p>"""
        ))
        self.synchronizationAct.triggered.connect(
            self.__showSyncDialog)
        self.__actions.append(self.synchronizationAct)
        
        self.zoomValuesAct = E5Action(
            self.tr('Manage Saved Zoom Values'),
            UI.PixmapCache.getIcon("zoomReset.png"),
            self.tr('Manage Saved Zoom Values...'),
            0, 0,
            self, 'help_manage_zoom_values')
        self.zoomValuesAct.setStatusTip(self.tr(
            'Manage the saved zoom values'))
        self.zoomValuesAct.setWhatsThis(self.tr(
            """<b>Manage Saved Zoom Values...</b>"""
            """<p>Opens a dialog to manage the saved zoom values.</p>"""
        ))
        self.zoomValuesAct.triggered.connect(self.__showZoomValuesDialog)
        self.__actions.append(self.zoomValuesAct)

        self.shortcutsAct = E5Action(
            self.tr('Keyboard Shortcuts'),
            UI.PixmapCache.getIcon("configureShortcuts.png"),
            self.tr('Keyboard &Shortcuts...'),
            0, 0,
            self, 'webbrowser_keyboard_shortcuts')
        self.shortcutsAct.setStatusTip(self.tr(
            'Set the keyboard shortcuts'))
        self.shortcutsAct.setWhatsThis(self.tr(
            """<b>Keyboard Shortcuts</b>"""
            """<p>Set the keyboard shortcuts of the application"""
            """ with your prefered values.</p>"""
        ))
        self.shortcutsAct.triggered.connect(self.__configShortcuts)
        self.__actions.append(self.shortcutsAct)

        self.exportShortcutsAct = E5Action(
            self.tr('Export Keyboard Shortcuts'),
            UI.PixmapCache.getIcon("exportShortcuts.png"),
            self.tr('&Export Keyboard Shortcuts...'),
            0, 0, self, 'export_keyboard_shortcuts')
        self.exportShortcutsAct.setStatusTip(self.tr(
            'Export the keyboard shortcuts'))
        self.exportShortcutsAct.setWhatsThis(self.tr(
            """<b>Export Keyboard Shortcuts</b>"""
            """<p>Export the keyboard shortcuts of the application.</p>"""
        ))
        self.exportShortcutsAct.triggered.connect(self.__exportShortcuts)
        self.__actions.append(self.exportShortcutsAct)

        self.importShortcutsAct = E5Action(
            self.tr('Import Keyboard Shortcuts'),
            UI.PixmapCache.getIcon("importShortcuts.png"),
            self.tr('&Import Keyboard Shortcuts...'),
            0, 0, self, 'import_keyboard_shortcuts')
        self.importShortcutsAct.setStatusTip(self.tr(
            'Import the keyboard shortcuts'))
        self.importShortcutsAct.setWhatsThis(self.tr(
            """<b>Import Keyboard Shortcuts</b>"""
            """<p>Import the keyboard shortcuts of the application.</p>"""
        ))
        self.importShortcutsAct.triggered.connect(self.__importShortcuts)
        self.__actions.append(self.importShortcutsAct)
        
        self.backAct.setEnabled(False)
        self.forwardAct.setEnabled(False)
        
        # now read the keyboard shortcuts for the actions
        Shortcuts.readShortcuts(helpViewer=self)
    
    def getActions(self):
        """
        Public method to get a list of all actions.
        
        @return list of all actions (list of E5Action)
        """
        return self.__actions[:]
    
    def getActionsCategory(self):
        """
        Public method to get the category of the defined actions.
        
        @return category of the actions
        @rtype str
        """
        return "HelpViewer"
    
    def __initMenus(self):
        """
        Private method to create the menus.
        """
        mb = self.menuBar()
        
        menu = mb.addMenu(self.tr('&File'))
        menu.setTearOffEnabled(True)
        menu.addAction(self.newTabAct)
        menu.addAction(self.newAct)
        menu.addAction(self.openAct)
        menu.addAction(self.openTabAct)
        menu.addSeparator()
        menu.addAction(self.saveAsAct)
        menu.addAction(self.savePageScreenAct)
        menu.addAction(self.saveVisiblePageScreenAct)
        menu.addSeparator()
        menu.addAction(self.printPreviewAct)
        menu.addAction(self.printAct)
        if self.printPdfAct:
            menu.addAction(self.printPdfAct)
        menu.addSeparator()
        menu.addAction(self.closeAct)
        menu.addAction(self.closeAllAct)
        menu.addSeparator()
        menu.addAction(self.privateBrowsingAct)
        menu.addSeparator()
        menu.addAction(self.exitAct)
        
        menu = mb.addMenu(self.tr('&Edit'))
        menu.setTearOffEnabled(True)
        menu.addAction(self.copyAct)
        menu.addSeparator()
        menu.addAction(self.findAct)
        menu.addAction(self.findNextAct)
        menu.addAction(self.findPrevAct)
        
        menu = mb.addMenu(self.tr('&View'))
        menu.setTearOffEnabled(True)
        menu.addAction(self.zoomInAct)
        menu.addAction(self.zoomResetAct)
        menu.addAction(self.zoomOutAct)
        if self.zoomTextOnlyAct is not None:
            menu.addAction(self.zoomTextOnlyAct)
        menu.addSeparator()
        menu.addAction(self.pageSourceAct)
        menu.addAction(self.fullScreenAct)
        if hasattr(QWebSettings, 'defaultTextEncoding'):
            self.__textEncodingMenu = menu.addMenu(
                self.tr("Text Encoding"))
            self.__textEncodingMenu.aboutToShow.connect(
                self.__aboutToShowTextEncodingMenu)
            self.__textEncodingMenu.triggered.connect(self.__setTextEncoding)
        
        menu = mb.addMenu(self.tr('&Go'))
        menu.setTearOffEnabled(True)
        menu.addAction(self.backAct)
        menu.addAction(self.forwardAct)
        menu.addAction(self.homeAct)
        menu.addSeparator()
        menu.addAction(self.stopAct)
        menu.addAction(self.reloadAct)
        if HelpWindow._useQtHelp:
            menu.addSeparator()
            menu.addAction(self.syncTocAct)
        
        from .History.HistoryMenu import HistoryMenu
        self.historyMenu = HistoryMenu(self, self.tabWidget)
        self.historyMenu.setTearOffEnabled(True)
        self.historyMenu.setTitle(self.tr('H&istory'))
        self.historyMenu.openUrl.connect(self.openUrl)
        self.historyMenu.newUrl.connect(self.openUrlNewTab)
        mb.addMenu(self.historyMenu)
        
        from .Bookmarks.BookmarksMenu import BookmarksMenuBarMenu
        self.bookmarksMenu = BookmarksMenuBarMenu(self)
        self.bookmarksMenu.setTearOffEnabled(True)
        self.bookmarksMenu.setTitle(self.tr('&Bookmarks'))
        self.bookmarksMenu.openUrl.connect(self.openUrl)
        self.bookmarksMenu.newUrl.connect(self.openUrlNewTab)
        mb.addMenu(self.bookmarksMenu)
        
        bookmarksActions = []
        bookmarksActions.append(self.bookmarksManageAct)
        bookmarksActions.append(self.bookmarksAddAct)
        bookmarksActions.append(self.bookmarksAllTabsAct)
        bookmarksActions.append(self.bookmarksAddFolderAct)
        bookmarksActions.append("--SEPARATOR--")
        bookmarksActions.append(self.importBookmarksAct)
        bookmarksActions.append(self.exportBookmarksAct)
        self.bookmarksMenu.setInitialActions(bookmarksActions)
        
        menu = mb.addMenu(self.tr('&Settings'))
        menu.setTearOffEnabled(True)
        menu.addAction(self.prefAct)
        menu.addSeparator()
        menu.addAction(self.shortcutsAct)
        menu.addAction(self.exportShortcutsAct)
        menu.addAction(self.importShortcutsAct)
        menu.addSeparator()
        menu.addAction(self.acceptedLanguagesAct)
        menu.addAction(self.cookiesAct)
        menu.addAction(self.flashCookiesAct)
        menu.addAction(self.offlineStorageAct)
        menu.addAction(self.personalDataAct)
        menu.addAction(self.greaseMonkeyAct)
        menu.addAction(self.featurePermissionAct)
        menu.addSeparator()
        menu.addAction(self.editMessageFilterAct)
        menu.addSeparator()
        menu.addAction(self.searchEnginesAct)
        menu.addSeparator()
        menu.addAction(self.passwordsAct)
        if SSL_AVAILABLE:
            menu.addAction(self.certificatesAct)
        menu.addSeparator()
        menu.addAction(self.zoomValuesAct)
        menu.addSeparator()
        menu.addAction(self.adblockAct)
        menu.addAction(self.flashblockAct)
        menu.addSeparator()
        self.__settingsMenu = menu
        self.__settingsMenu.aboutToShow.connect(
            self.__aboutToShowSettingsMenu)
        
        from .UserAgent.UserAgentMenu import UserAgentMenu
        self.__userAgentMenu = UserAgentMenu(self.tr("Global User Agent"))
        menu.addMenu(self.__userAgentMenu)
        menu.addAction(self.userAgentManagerAct)
        menu.addSeparator()
        
        if HelpWindow._useQtHelp:
            menu.addAction(self.manageQtHelpDocsAct)
            menu.addAction(self.manageQtHelpFiltersAct)
            menu.addAction(self.reindexDocumentationAct)
            menu.addSeparator()
        menu.addAction(self.clearPrivateDataAct)
        menu.addAction(self.clearIconsAct)
        
        menu = mb.addMenu(self.tr("&Tools"))
        menu.setTearOffEnabled(True)
        menu.addAction(self.feedsManagerAct)
        menu.addAction(self.siteInfoAct)
        menu.addSeparator()
        menu.addAction(self.synchronizationAct)
        menu.addSeparator()
        menu.addAction(self.toolsMonitorAct)
        
        menu = mb.addMenu(self.tr("&Window"))
        menu.setTearOffEnabled(True)
        menu.addAction(self.showDownloadManagerAct)
        if HelpWindow._useQtHelp:
            menu.addSeparator()
            menu.addAction(self.showTocAct)
            menu.addAction(self.showIndexAct)
            menu.addAction(self.showSearchAct)
        
        mb.addSeparator()
        
        menu = mb.addMenu(self.tr('&Help'))
        menu.setTearOffEnabled(True)
        menu.addAction(self.aboutAct)
        menu.addAction(self.aboutQtAct)
        menu.addSeparator()
        menu.addAction(self.whatsThisAct)
    
    def __initToolbars(self):
        """
        Private method to create the toolbars.
        """
        filetb = self.addToolBar(self.tr("File"))
        filetb.setObjectName("FileToolBar")
        filetb.setIconSize(UI.Config.ToolBarIconSize)
        filetb.addAction(self.newTabAct)
        filetb.addAction(self.newAct)
        filetb.addAction(self.openAct)
        filetb.addAction(self.openTabAct)
        filetb.addSeparator()
        filetb.addAction(self.saveAsAct)
        filetb.addAction(self.savePageScreenAct)
        filetb.addSeparator()
        filetb.addAction(self.printPreviewAct)
        filetb.addAction(self.printAct)
        if self.printPdfAct:
            filetb.addAction(self.printPdfAct)
        filetb.addSeparator()
        filetb.addAction(self.closeAct)
        filetb.addAction(self.exitAct)
        
        self.savePageScreenMenu = QMenu(self)
        self.savePageScreenMenu.addAction(self.savePageScreenAct)
        self.savePageScreenMenu.addAction(self.saveVisiblePageScreenAct)
        savePageScreenButton = filetb.widgetForAction(self.savePageScreenAct)
        savePageScreenButton.setMenu(self.savePageScreenMenu)
        savePageScreenButton.setPopupMode(QToolButton.MenuButtonPopup)
        
        edittb = self.addToolBar(self.tr("Edit"))
        edittb.setObjectName("EditToolBar")
        edittb.setIconSize(UI.Config.ToolBarIconSize)
        edittb.addAction(self.copyAct)
        
        viewtb = self.addToolBar(self.tr("View"))
        viewtb.setObjectName("ViewToolBar")
        viewtb.setIconSize(UI.Config.ToolBarIconSize)
        viewtb.addAction(self.zoomInAct)
        viewtb.addAction(self.zoomResetAct)
        viewtb.addAction(self.zoomOutAct)
        viewtb.addSeparator()
        viewtb.addAction(self.fullScreenAct)
        
        findtb = self.addToolBar(self.tr("Find"))
        findtb.setObjectName("FindToolBar")
        findtb.setIconSize(UI.Config.ToolBarIconSize)
        findtb.addAction(self.findAct)
        findtb.addAction(self.findNextAct)
        findtb.addAction(self.findPrevAct)
        
        if HelpWindow._useQtHelp:
            filtertb = self.addToolBar(self.tr("Filter"))
            filtertb.setObjectName("FilterToolBar")
            self.filterCombo = QComboBox()
            self.filterCombo.setMinimumWidth(
                QFontMetrics(QFont()).width("ComboBoxWithEnoughWidth"))
            filtertb.addWidget(QLabel(self.tr("Filtered by: ")))
            filtertb.addWidget(self.filterCombo)
            self.__helpEngine.setupFinished.connect(self.__setupFilterCombo)
            self.filterCombo.activated[str].connect(
                self.__filterQtHelpDocumentation)
            self.__setupFilterCombo()
        
        settingstb = self.addToolBar(self.tr("Settings"))
        settingstb.setObjectName("SettingsToolBar")
        settingstb.setIconSize(UI.Config.ToolBarIconSize)
        settingstb.addAction(self.prefAct)
        settingstb.addAction(self.shortcutsAct)
        settingstb.addAction(self.acceptedLanguagesAct)
        settingstb.addAction(self.cookiesAct)
        settingstb.addAction(self.flashCookiesAct)
        settingstb.addAction(self.offlineStorageAct)
        settingstb.addAction(self.personalDataAct)
        settingstb.addAction(self.greaseMonkeyAct)
        settingstb.addAction(self.featurePermissionAct)
        
        toolstb = self.addToolBar(self.tr("Tools"))
        toolstb.setObjectName("ToolsToolBar")
        toolstb.setIconSize(UI.Config.ToolBarIconSize)
        toolstb.addAction(self.feedsManagerAct)
        toolstb.addAction(self.siteInfoAct)
        toolstb.addSeparator()
        toolstb.addAction(self.synchronizationAct)
        
        helptb = self.addToolBar(self.tr("Help"))
        helptb.setObjectName("HelpToolBar")
        helptb.setIconSize(UI.Config.ToolBarIconSize)
        helptb.addAction(self.whatsThisAct)
        
        self.addToolBarBreak()
        
        gotb = self.addToolBar(self.tr("Go"))
        gotb.setObjectName("GoToolBar")
        gotb.setIconSize(UI.Config.ToolBarIconSize)
        gotb.addAction(self.backAct)
        gotb.addAction(self.forwardAct)
        gotb.addAction(self.reloadAct)
        gotb.addAction(self.stopAct)
        gotb.addAction(self.homeAct)
        gotb.addSeparator()
        
        self.__navigationSplitter = QSplitter(gotb)
        self.__navigationSplitter.addWidget(self.tabWidget.stackedUrlBar())
        
        from .HelpWebSearchWidget import HelpWebSearchWidget
        self.searchEdit = HelpWebSearchWidget(self)
        sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        sizePolicy.setHorizontalStretch(2)
        sizePolicy.setVerticalStretch(0)
        self.searchEdit.setSizePolicy(sizePolicy)
        self.searchEdit.search.connect(self.__linkActivated)
        self.__navigationSplitter.addWidget(self.searchEdit)
        gotb.addWidget(self.__navigationSplitter)
        
        self.__navigationSplitter.setSizePolicy(
            QSizePolicy.Expanding, QSizePolicy.Maximum)
        self.__navigationSplitter.setCollapsible(0, False)
        
        self.backMenu = QMenu(self)
        self.backMenu.aboutToShow.connect(self.__showBackMenu)
        self.backMenu.triggered.connect(self.__navigationMenuActionTriggered)
        backButton = gotb.widgetForAction(self.backAct)
        backButton.setMenu(self.backMenu)
        backButton.setPopupMode(QToolButton.MenuButtonPopup)
        
        self.forwardMenu = QMenu(self)
        self.forwardMenu.aboutToShow.connect(self.__showForwardMenu)
        self.forwardMenu.triggered.connect(
            self.__navigationMenuActionTriggered)
        forwardButton = gotb.widgetForAction(self.forwardAct)
        forwardButton.setMenu(self.forwardMenu)
        forwardButton.setPopupMode(QToolButton.MenuButtonPopup)
        
        from .Bookmarks.BookmarksToolBar import BookmarksToolBar
        bookmarksModel = self.bookmarksManager().bookmarksModel()
        self.bookmarksToolBar = BookmarksToolBar(self, bookmarksModel, self)
        self.bookmarksToolBar.setObjectName("BookmarksToolBar")
        self.bookmarksToolBar.setIconSize(UI.Config.ToolBarIconSize)
        self.bookmarksToolBar.openUrl.connect(self.openUrl)
        self.bookmarksToolBar.newUrl.connect(self.openUrlNewTab)
        self.addToolBarBreak()
        self.addToolBar(self.bookmarksToolBar)
        
        self.addToolBarBreak()
        vttb = self.addToolBar(self.tr("VirusTotal"))
        vttb.setObjectName("VirusTotalToolBar")
        vttb.setIconSize(UI.Config.ToolBarIconSize)
        vttb.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self.virustotalScanCurrentAct = vttb.addAction(
            UI.PixmapCache.getIcon("virustotal.png"),
            self.tr("Scan current site"),
            self.__virusTotalScanCurrentSite)
        self.virustotalIpReportAct = vttb.addAction(
            UI.PixmapCache.getIcon("virustotal.png"),
            self.tr("IP Address Report"),
            self.__virusTotalIpAddressReport)
        self.virustotalDomainReportAct = vttb.addAction(
            UI.PixmapCache.getIcon("virustotal.png"),
            self.tr("Domain Report"),
            self.__virusTotalDomainReport)
        if not Preferences.getHelp("VirusTotalEnabled") or \
           Preferences.getHelp("VirusTotalServiceKey") == "":
            self.virustotalScanCurrentAct.setEnabled(False)
            self.virustotalIpReportAct.setEnabled(False)
            self.virustotalDomainReportAct.setEnabled(False)
        
    def __nextTab(self):
        """
        Private slot used to show the next tab.
        """
        fwidget = QApplication.focusWidget()
        while fwidget and not hasattr(fwidget, 'nextTab'):
            fwidget = fwidget.parent()
        if fwidget:
            fwidget.nextTab()
        
    def __prevTab(self):
        """
        Private slot used to show the previous tab.
        """
        fwidget = QApplication.focusWidget()
        while fwidget and not hasattr(fwidget, 'prevTab'):
            fwidget = fwidget.parent()
        if fwidget:
            fwidget.prevTab()
        
    def __switchTab(self):
        """
        Private slot used to switch between the current and the previous
        current tab.
        """
        fwidget = QApplication.focusWidget()
        while fwidget and not hasattr(fwidget, 'switchTab'):
            fwidget = fwidget.parent()
        if fwidget:
            fwidget.switchTab()
        
    def __whatsThis(self):
        """
        Private slot called in to enter Whats This mode.
        """
        QWhatsThis.enterWhatsThisMode()
        
    def __titleChanged(self, browser, title):
        """
        Private slot called to handle a change of s browser's title.
        
        @param browser reference to the browser (HelpBrowser)
        @param title new title (string)
        """
        self.historyManager().updateHistoryEntry(
            browser.url().toString(), title)
    
    @pyqtSlot()
    def newTab(self, link=None, requestData=None, addNextTo=None):
        """
        Public slot called to open a new help window tab.
        
        @param link file to be displayed in the new window (string or QUrl)
        @param requestData tuple containing the request data (QNetworkRequest,
            QNetworkAccessManager.Operation, QByteArray)
        @param addNextTo reference to the browser to open the tab after
            (HelpBrowser)
        """
        if addNextTo:
            self.tabWidget.newBrowserAfter(addNextTo, link, requestData)
        else:
            self.tabWidget.newBrowser(link, requestData)
    
    @pyqtSlot()
    def newWindow(self, link=None):
        """
        Public slot called to open a new help browser dialog.
        
        @param link file to be displayed in the new window (string or QUrl)
        """
        if link is None:
            linkName = ""
        elif isinstance(link, QUrl):
            linkName = link.toString()
        else:
            linkName = link
        h = HelpWindow(linkName, ".", self.parent(), "qbrowser")
        h.show()
    
    def __openFile(self):
        """
        Private slot called to open a file.
        """
        fn = E5FileDialog.getOpenFileName(
            self,
            self.tr("Open File"),
            "",
            self.tr("Help Files (*.html *.htm);;"
                    "PDF Files (*.pdf);;"
                    "CHM Files (*.chm);;"
                    "All Files (*)"
                    ))
        if fn:
            if Utilities.isWindowsPlatform():
                url = "file:///" + Utilities.fromNativeSeparators(fn)
            else:
                url = "file://" + fn
            self.currentBrowser().setSource(QUrl(url))
        
    def __openFileNewTab(self):
        """
        Private slot called to open a file in a new tab.
        """
        fn = E5FileDialog.getOpenFileName(
            self,
            self.tr("Open File"),
            "",
            self.tr("Help Files (*.html *.htm);;"
                    "PDF Files (*.pdf);;"
                    "CHM Files (*.chm);;"
                    "All Files (*)"
                    ))
        if fn:
            if Utilities.isWindowsPlatform():
                url = "file:///" + Utilities.fromNativeSeparators(fn)
            else:
                url = "file://" + fn
            self.newTab(url)
        
    def __savePageAs(self):
        """
        Private slot to save the current page.
        """
        browser = self.currentBrowser()
        if browser is not None:
            browser.saveAs()
    
    @pyqtSlot()
    def __savePageScreen(self, visibleOnly=False):
        """
        Private slot to save the current page as a screen shot.
        
        @param visibleOnly flag indicating to just save the visible part
            of the page (boolean)
        """
        from .PageScreenDialog import PageScreenDialog
        self.__pageScreen = PageScreenDialog(
            self.currentBrowser(), visibleOnly=visibleOnly)
        self.__pageScreen.show()
        
    def __saveVisiblePageScreen(self):
        """
        Private slot to save the visible part of the current page as a screen
        shot.
        """
        self.__savePageScreen(visibleOnly=True)
        
    def __about(self):
        """
        Private slot to show the about information.
        """
        E5MessageBox.about(
            self,
            self.tr("eric6 Web Browser"),
            self.tr(
                """<b>eric6 Web Browser - {0}</b>"""
                """<p>The eric6 Web Browser is a combined help file and HTML"""
                """ browser. It is part of the eric6 development"""
                """ toolset.</p>"""
            ).format(Version))
        
    def __aboutQt(self):
        """
        Private slot to show info about Qt.
        """
        E5MessageBox.aboutQt(self, self.tr("eric6 Web Browser"))

    def setBackwardAvailable(self, b):
        """
        Public slot called when backward references are available.
        
        @param b flag indicating availability of the backwards action (boolean)
        """
        self.backAct.setEnabled(b)
        
    def setForwardAvailable(self, b):
        """
        Public slot called when forward references are available.
        
        @param b flag indicating the availability of the forwards action
            (boolean)
        """
        self.forwardAct.setEnabled(b)
        
    def setLoadingActions(self, b):
        """
        Public slot to set the loading dependent actions.
        
        @param b flag indicating the loading state to consider (boolean)
        """
        self.reloadAct.setEnabled(not b)
        self.stopAct.setEnabled(b)
        
    def __addBookmark(self):
        """
        Private slot called to add the displayed file to the bookmarks.
        """
        view = self.currentBrowser()
        url = bytes(view.url().toEncoded()).decode()
        title = view.title()
        description = ""
        meta = view.page().mainFrame().metaData()
        if "description" in meta:
            description = meta["description"][0]
        
        from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
        dlg = AddBookmarkDialog()
        dlg.setUrl(url)
        dlg.setTitle(title)
        dlg.setDescription(description)
        menu = self.bookmarksManager().menu()
        idx = self.bookmarksManager().bookmarksModel().nodeIndex(menu)
        dlg.setCurrentIndex(idx)
        dlg.exec_()
        
    def __addBookmarkFolder(self):
        """
        Private slot to add a new bookmarks folder.
        """
        from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
        dlg = AddBookmarkDialog()
        menu = self.bookmarksManager().menu()
        idx = self.bookmarksManager().bookmarksModel().nodeIndex(menu)
        dlg.setCurrentIndex(idx)
        dlg.setFolder(True)
        dlg.exec_()
        
    def __showBookmarksDialog(self):
        """
        Private slot to show the bookmarks dialog.
        """
        from .Bookmarks.BookmarksDialog import BookmarksDialog
        self.__bookmarksDialog = BookmarksDialog(self)
        self.__bookmarksDialog.openUrl.connect(self.openUrl)
        self.__bookmarksDialog.newUrl.connect(self.openUrlNewTab)
        self.__bookmarksDialog.show()
        
    def bookmarkAll(self):
        """
        Public slot to bookmark all open tabs.
        """
        from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
        dlg = AddBookmarkDialog()
        dlg.setFolder(True)
        dlg.setTitle(self.tr("Saved Tabs"))
        dlg.exec_()
        
        folder = dlg.addedNode()
        if folder is None:
            return
        
        from .Bookmarks.BookmarkNode import BookmarkNode
        for browser in self.tabWidget.browsers():
            bookmark = BookmarkNode(BookmarkNode.Bookmark)
            bookmark.url = bytes(browser.url().toEncoded()).decode()
            bookmark.title = browser.title()
            meta = browser.page().mainFrame().metaData()
            if "description" in meta:
                bookmark.desc = meta["description"][0]
            
            self.bookmarksManager().addBookmark(folder, bookmark)
        
    def __find(self):
        """
        Private slot to handle the find action.
        
        It opens the search dialog in order to perform the various
        search actions and to collect the various search info.
        """
        self.findDlg.showFind()
        
    def __closeAllWindows(self):
        """
        Private slot to close all windows.
        """
        for browser in HelpWindow.helpwindows:
            if browser != self:
                browser.close()
        self.close()
        
    def closeEvent(self, e):
        """
        Protected event handler for the close event.
        
        @param e the close event (QCloseEvent)
                <br />This event is simply accepted after the history has been
                saved and all window references have been deleted.
        """
        if not self.__shutdownCalled:
            res = self.shutdown()
            
            if res:
                e.accept()
                self.helpClosed.emit()
            else:
                e.ignore()
        else:
            e.accept()
    
    def shutdown(self):
        """
        Public method to shut down the web browser.
        
        @return flag indicating successful shutdown (boolean)
        """
        if not self.tabWidget.shallShutDown():
            return False
        
        if not self.downloadManager().allowQuit():
            return False
        
        self.downloadManager().shutdown()
        
        self.__closeNetworkMonitor()
        
        self.cookieJar().close()
        
        self.bookmarksToolBar.setModel(None)
        self.bookmarksManager().close()
        
        self.historyManager().close()
        
        self.passwordManager().close()
        
        self.adBlockManager().close()
        
        self.userAgentsManager().close()
        
        self.speedDial().close()
        
        self.syncManager().close()
        
        self.zoomManager().close()
        
        self.__virusTotal.close()
        
        self.flashCookieManager().shutdown()
        
        self.searchEdit.openSearchManager().close()
        
        if HelpWindow._useQtHelp:
            self.__searchEngine.cancelIndexing()
            self.__searchEngine.cancelSearching()
            
            if self.__helpInstaller:
                self.__helpInstaller.stop()
        
        self.searchEdit.saveSearches()
        
        self.tabWidget.closeAllBrowsers()
        
        state = self.saveState()
        Preferences.setHelp("HelpViewerState", state)

        if Preferences.getHelp("SaveGeometry"):
            if not self.__isFullScreen():
                Preferences.setGeometry("HelpViewerGeometry",
                                        self.saveGeometry())
        else:
            Preferences.setGeometry("HelpViewerGeometry", QByteArray())
        
        try:
            browserIndex = HelpWindow.helpwindows.index(self)
            if len(HelpWindow.helpwindows):
                if browserIndex == 0:
                    if len(HelpWindow.helpwindows) > 1:
                        # first window will be deleted
                        QDesktopServices.setUrlHandler(
                            "http",
                            HelpWindow.helpwindows[1].urlHandler)
                        QDesktopServices.setUrlHandler(
                            "https",
                            HelpWindow.helpwindows[1].urlHandler)
                    else:
                        QDesktopServices.unsetUrlHandler("http")
                        QDesktopServices.unsetUrlHandler("https")
            if len(HelpWindow.helpwindows) > 0:
                del HelpWindow.helpwindows[browserIndex]
        except ValueError:
            pass
        
        Preferences.syncPreferences()
        
        self.__shutdownCalled = True
        return True

    def __backward(self):
        """
        Private slot called to handle the backward action.
        """
        self.currentBrowser().backward()
    
    def __forward(self):
        """
        Private slot called to handle the forward action.
        """
        self.currentBrowser().forward()
    
    def __home(self):
        """
        Private slot called to handle the home action.
        """
        self.currentBrowser().home()
    
    def __reload(self):
        """
        Private slot called to handle the reload action.
        """
        self.currentBrowser().reload()
    
    def __stopLoading(self):
        """
        Private slot called to handle loading of the current page.
        """
        self.currentBrowser().stop()
    
    def __zoomValueChanged(self, value):
        """
        Private slot to handle value changes of the zoom widget.
        
        @param value zoom value (integer)
        """
        self.currentBrowser().setZoomValue(value)
    
    def __zoomIn(self):
        """
        Private slot called to handle the zoom in action.
        """
        self.currentBrowser().zoomIn()
        self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
    
    def __zoomOut(self):
        """
        Private slot called to handle the zoom out action.
        """
        self.currentBrowser().zoomOut()
        self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
    
    def __zoomReset(self):
        """
        Private slot called to handle the zoom reset action.
        """
        self.currentBrowser().zoomReset()
        self.__zoomWidget.setValue(self.currentBrowser().zoomValue())
    
    def __zoomTextOnly(self, textOnly):
        """
        Private slot called to handle the zoom text only action.
        
        @param textOnly flag indicating to zoom text only (boolean)
        """
        QWebSettings.globalSettings().setAttribute(
            QWebSettings.ZoomTextOnly, textOnly)
        self.zoomTextOnlyChanged.emit(textOnly)
    
    def __viewFullScreen(self):
        """
        Private slot called to toggle fullscreen mode.
        """
        if self.__isFullScreen():
            # switch back to normal
            self.setWindowState(self.windowState() & ~Qt.WindowFullScreen)
            self.menuBar().show()
            self.fullScreenAct.setIcon(
                UI.PixmapCache.getIcon("windowFullscreen.png"))
            self.fullScreenAct.setIconText(self.tr('Full Screen'))
        else:
            # switch to full screen
            self.setWindowState(self.windowState() | Qt.WindowFullScreen)
            self.menuBar().hide()
            self.fullScreenAct.setIcon(
                UI.PixmapCache.getIcon("windowRestore.png"))
            self.fullScreenAct.setIconText(self.tr('Restore Window'))
    
    def __isFullScreen(self):
        """
        Private method to determine, if the window is in full screen mode.
        
        @return flag indicating full screen mode (boolean)
        """
        return self.windowState() & Qt.WindowFullScreen
    
    def __copy(self):
        """
        Private slot called to handle the copy action.
        """
        self.currentBrowser().copy()
    
    def __privateBrowsing(self):
        """
        Private slot to switch private browsing.
        """
        settings = QWebSettings.globalSettings()
        pb = settings.testAttribute(QWebSettings.PrivateBrowsingEnabled)
        if not pb:
            txt = self.tr(
                """<b>Are you sure you want to turn on private"""
                """ browsing?</b><p>When private browsing is turned on,"""
                """ web pages are not added to the history, searches"""
                """ are not added to the list of recent searches and"""
                """ web site icons and cookies are not stored."""
                """ HTML5 offline storage will be deactivated."""
                """ Until you close the window, you can still click"""
                """ the Back and Forward buttons to return to the"""
                """ web pages you have opened.</p>""")
            res = E5MessageBox.yesNo(self, "", txt)
            if res:
                self.setPrivateMode(True)
        else:
            self.setPrivateMode(False)
    
    def setPrivateMode(self, on):
        """
        Public method to set the privacy mode.
        
        @param on flag indicating the privacy state (boolean)
        """
        QWebSettings.globalSettings().setAttribute(
            QWebSettings.PrivateBrowsingEnabled, on)
        if on:
            self.__setIconDatabasePath(False)
        else:
            self.__setIconDatabasePath(True)
        self.privateBrowsingAct.setChecked(on)
        self.privacyChanged.emit(on)
    
    def currentBrowser(self):
        """
        Public method to get a reference to the current help browser.
        
        @return reference to the current help browser (HelpBrowser)
        """
        return self.tabWidget.currentBrowser()
    
    def browserAt(self, index):
        """
        Public method to get a reference to the help browser with the given
        index.
        
        @param index index of the browser to get (integer)
        @return reference to the indexed help browser (HelpBrowser)
        """
        return self.tabWidget.browserAt(index)
    
    def browsers(self):
        """
        Public method to get a list of references to all help browsers.
        
        @return list of references to help browsers (list of HelpBrowser)
        """
        return self.tabWidget.browsers()
    
    def __currentChanged(self, index):
        """
        Private slot to handle the currentChanged signal.
        
        @param index index of the current tab (integer)
        """
        if index > -1:
            cb = self.currentBrowser()
            if cb is not None:
                self.setForwardAvailable(cb.isForwardAvailable())
                self.setBackwardAvailable(cb.isBackwardAvailable())
                self.setLoadingActions(cb.isLoading())
                
                # set value of zoom widget
                self.__zoomWidget.setValue(cb.zoomValue())
    
    def __showPreferences(self):
        """
        Private slot to set the preferences.
        """
        from Preferences.ConfigurationDialog import ConfigurationDialog
        dlg = ConfigurationDialog(
            self, 'Configuration', True, fromEric=False,
            displayMode=ConfigurationDialog.HelpBrowserMode)
        dlg.preferencesChanged.connect(self.preferencesChanged)
        dlg.masterPasswordChanged.connect(
            lambda old, new: self.masterPasswordChanged(old, new, local=True))
        dlg.show()
        if self.__lastConfigurationPageName:
            dlg.showConfigurationPageByName(self.__lastConfigurationPageName)
        else:
            dlg.showConfigurationPageByName("empty")
        dlg.exec_()
        QApplication.processEvents()
        if dlg.result() == QDialog.Accepted:
            dlg.setPreferences()
            Preferences.syncPreferences()
            self.preferencesChanged()
        self.__lastConfigurationPageName = dlg.getConfigurationPageName()
    
    def preferencesChanged(self):
        """
        Public slot to handle a change of preferences.
        """
        self.setStyle(Preferences.getUI("Style"),
                      Preferences.getUI("StyleSheet"))
        
        self.__initWebSettings()
        
        self.networkAccessManager().preferencesChanged()
        
        self.historyManager().preferencesChanged()
        
        self.tabWidget.preferencesChanged()
        
        self.searchEdit.preferencesChanged()
        
        self.__virusTotal.preferencesChanged()
        if not Preferences.getHelp("VirusTotalEnabled") or \
           Preferences.getHelp("VirusTotalServiceKey") == "":
            self.virustotalScanCurrentAct.setEnabled(False)
            self.virustotalIpReportAct.setEnabled(False)
            self.virustotalDomainReportAct.setEnabled(False)
        else:
            self.virustotalScanCurrentAct.setEnabled(True)
            self.virustotalIpReportAct.setEnabled(True)
            self.virustotalDomainReportAct.setEnabled(True)
    
    def masterPasswordChanged(self, oldPassword, newPassword, local=False):
        """
        Public slot to handle the change of the master password.
        
        @param oldPassword current master password
        @type str
        @param newPassword new master password
        @type str
        @param local flag indicating being called from the local configuration
            dialog
        @type bool
        """
        self.passwordManager().masterPasswordChanged(oldPassword, newPassword)
        if local:
            # we were called from our local configuration dialog
            Preferences.convertPasswords(oldPassword, newPassword)
            Utilities.crypto.changeRememberedMaster(newPassword)
    
    def __showAcceptedLanguages(self):
        """
        Private slot to configure the accepted languages for web pages.
        """
        from .HelpLanguagesDialog import HelpLanguagesDialog
        dlg = HelpLanguagesDialog(self)
        dlg.exec_()
        self.networkAccessManager().languagesChanged()
    
    def __showCookiesConfiguration(self):
        """
        Private slot to configure the cookies handling.
        """
        from .CookieJar.CookiesConfigurationDialog import \
            CookiesConfigurationDialog
        dlg = CookiesConfigurationDialog(self)
        dlg.exec_()
    
    def __showFlashCookiesManagement(self):
        """
        Private slot to show the flash cookies management dialog.
        """
        self.flashCookieManager().showFlashCookieManagerDialog()
    
    def __showOfflineStorageConfiguration(self):
        """
        Private slot to configure the offline storage.
        """
        from .OfflineStorage.OfflineStorageConfigDialog import \
            OfflineStorageConfigDialog
        dlg = OfflineStorageConfigDialog(self)
        if dlg.exec_() == QDialog.Accepted:
            dlg.storeData()
            self.__initWebSettings()
    
    @classmethod
    def setUseQtHelp(cls, use):
        """
        Class method to set the QtHelp usage.
        
        @param use flag indicating usage (boolean)
        """
        if use:
            cls._useQtHelp = use and QTHELP_AVAILABLE
        else:
            cls._useQtHelp = False
    
    @classmethod
    def helpEngine(cls):
        """
        Class method to get a reference to the help engine.
        
        @return reference to the help engine (QHelpEngine)
        """
        if cls._useQtHelp:
            if cls._helpEngine is None:
                cls._helpEngine = QHelpEngine(
                    HelpWindow.getQtHelpCollectionFileName())
            return cls._helpEngine
        else:
            return None
    
    @classmethod
    def getQtHelpCollectionFileName(cls):
        """
        Class method to determine the name of the QtHelp collection file.
        
        @return path of the QtHelp collection file
        @rtype str
        """
        qthelpDir = os.path.join(Utilities.getConfigDir(), "qthelp")
        if not os.path.exists(qthelpDir):
            os.makedirs(qthelpDir)
        return os.path.join(qthelpDir, "eric6help.qhc")
    
    @classmethod
    def networkAccessManager(cls):
        """
        Class method to get a reference to the network access manager.
        
        @return reference to the network access manager (NetworkAccessManager)
        """
        if cls._networkAccessManager is None:
            from .Network.NetworkAccessManager import NetworkAccessManager
            from .CookieJar.CookieJar import CookieJar
            cls._networkAccessManager = \
                NetworkAccessManager(cls.helpEngine())
            cls._cookieJar = CookieJar()
            cls._networkAccessManager.setCookieJar(cls._cookieJar)
        
        return cls._networkAccessManager
        
    @classmethod
    def cookieJar(cls):
        """
        Class method to get a reference to the cookie jar.
        
        @return reference to the cookie jar (CookieJar)
        """
        return cls.networkAccessManager().cookieJar()
        
    def __clearIconsDatabase(self):
        """
        Private slot to clear the icons databse.
        """
        QWebSettings.clearIconDatabase()
        
    @pyqtSlot(QUrl)
    def urlHandler(self, url):
        """
        Public slot used as desktop URL handler.
        
        @param url URL to be handled
        @type QUrl
        """
        self.__linkActivated(url)
    
    @pyqtSlot(QUrl)
    def __linkActivated(self, url):
        """
        Private slot to handle the selection of a link in the TOC window.
        
        @param url URL to be shown
        @type QUrl
        """
        if not self.__activating:
            self.__activating = True
            req = QNetworkRequest(url)
            req.setRawHeader(b"X-Eric6-UserLoadAction", b"1")
            cb = self.currentBrowser()
            if cb is None:
                self.newTab(
                    None, (req, QNetworkAccessManager.GetOperation, b""))
            else:
                cb.setSource(
                    None, (req, QNetworkAccessManager.GetOperation, b""))
            self.__activating = False
        
    def __linksActivated(self, links, keyword):
        """
        Private slot to select a topic to be shown.
        
        @param links dictionary with help topic as key (string) and
            URL as value (QUrl)
        @param keyword keyword for the link set (string)
        """
        if not self.__activating:
            from .HelpTopicDialog import HelpTopicDialog
            self.__activating = True
            dlg = HelpTopicDialog(self, keyword, links)
            if dlg.exec_() == QDialog.Accepted:
                self.currentBrowser().setSource(dlg.link())
            self.__activating = False
    
    def __activateCurrentBrowser(self):
        """
        Private slot to activate the current browser.
        """
        self.currentBrowser().setFocus()
        
    def __syncTOC(self):
        """
        Private slot to synchronize the TOC with the currently shown page.
        """
        if HelpWindow._useQtHelp:
            QApplication.setOverrideCursor(Qt.WaitCursor)
            url = self.currentBrowser().source()
            self.__showTocWindow()
            if not self.__tocWindow.syncToContent(url):
                self.statusBar().showMessage(
                    self.tr("Could not find an associated content."), 5000)
            QApplication.restoreOverrideCursor()
        
    def __showTocWindow(self):
        """
        Private method to show the table of contents window.
        """
        if HelpWindow._useQtHelp:
            self.__activateDock(self.__tocWindow)
        
    def __hideTocWindow(self):
        """
        Private method to hide the table of contents window.
        """
        if HelpWindow._useQtHelp:
            self.__tocDock.hide()
        
    def __showIndexWindow(self):
        """
        Private method to show the index window.
        """
        if HelpWindow._useQtHelp:
            self.__activateDock(self.__indexWindow)
        
    def __hideIndexWindow(self):
        """
        Private method to hide the index window.
        """
        if HelpWindow._useQtHelp:
            self.__indexDock.hide()
        
    def __showSearchWindow(self):
        """
        Private method to show the search window.
        """
        if HelpWindow._useQtHelp:
            self.__activateDock(self.__searchWindow)
        
    def __hideSearchWindow(self):
        """
        Private method to hide the search window.
        """
        if HelpWindow._useQtHelp:
            self.__searchDock.hide()
        
    def __activateDock(self, widget):
        """
        Private method to activate the dock widget of the given widget.
        
        @param widget reference to the widget to be activated (QWidget)
        """
        widget.parent().show()
        widget.parent().raise_()
        widget.setFocus()
        
    def __setupFilterCombo(self):
        """
        Private slot to setup the filter combo box.
        """
        if HelpWindow._useQtHelp:
            curFilter = self.filterCombo.currentText()
            if not curFilter:
                curFilter = self.__helpEngine.currentFilter()
            self.filterCombo.clear()
            self.filterCombo.addItems(self.__helpEngine.customFilters())
            idx = self.filterCombo.findText(curFilter)
            if idx < 0:
                idx = 0
            self.filterCombo.setCurrentIndex(idx)
        
    def __filterQtHelpDocumentation(self, customFilter):
        """
        Private slot to filter the QtHelp documentation.
        
        @param customFilter name of filter to be applied (string)
        """
        if self.__helpEngine:
            self.__helpEngine.setCurrentFilter(customFilter)
        
    def __manageQtHelpDocumentation(self):
        """
        Private slot to manage the QtHelp documentation database.
        """
        if HelpWindow._useQtHelp:
            from .QtHelpDocumentationDialog import QtHelpDocumentationDialog
            dlg = QtHelpDocumentationDialog(self.__helpEngine, self)
            dlg.exec_()
            if dlg.hasChanges():
                for i in sorted(dlg.getTabsToClose(), reverse=True):
                    self.tabWidget.closeBrowserAt(i)
                self.__helpEngine.setupData()
        
    def getSourceFileList(self):
        """
        Public method to get a list of all opened source files.
        
        @return dictionary with tab id as key and host/namespace as value
        """
        return self.tabWidget.getSourceFileList()
        
    def __manageQtHelpFilters(self):
        """
        Private slot to manage the QtHelp filters.
        """
        if HelpWindow._useQtHelp:
            from .QtHelpFiltersDialog import QtHelpFiltersDialog
            dlg = QtHelpFiltersDialog(self.__helpEngine, self)
            dlg.exec_()
        
    def __indexingStarted(self):
        """
        Private slot to handle the start of the indexing process.
        """
        if HelpWindow._useQtHelp:
            self.__indexing = True
            if self.__indexingProgress is None:
                self.__indexingProgress = QWidget()
                layout = QHBoxLayout(self.__indexingProgress)
                layout.setContentsMargins(0, 0, 0, 0)
                sizePolicy = QSizePolicy(QSizePolicy.Preferred,
                                         QSizePolicy.Maximum)
                
                label = QLabel(self.tr("Updating search index"))
                label.setSizePolicy(sizePolicy)
                layout.addWidget(label)
                
                progressBar = QProgressBar()
                progressBar.setRange(0, 0)
                progressBar.setTextVisible(False)
                progressBar.setFixedHeight(16)
                progressBar.setSizePolicy(sizePolicy)
                layout.addWidget(progressBar)
                
                self.statusBar().insertPermanentWidget(
                    0, self.__indexingProgress)
        
    def __indexingFinished(self):
        """
        Private slot to handle the start of the indexing process.
        """
        if HelpWindow._useQtHelp:
            self.statusBar().removeWidget(self.__indexingProgress)
            self.__indexingProgress = None
            self.__indexing = False
            if self.__searchWord is not None:
                self.__searchForWord()
        
    def __searchForWord(self):
        """
        Private slot to search for a word.
        """
        if HelpWindow._useQtHelp and not self.__indexing and \
                self.__searchWord is not None:
            self.__searchDock.show()
            self.__searchDock.raise_()
            query = QHelpSearchQuery(QHelpSearchQuery.DEFAULT,
                                     [self.__searchWord])
            self.__searchEngine.search([query])
            self.__searchWord = None
        
    def search(self, word):
        """
        Public method to search for a word.
        
        @param word word to search for (string)
        """
        if HelpWindow._useQtHelp:
            self.__searchWord = word
            self.__searchForWord()
        
    def __removeOldDocumentation(self):
        """
        Private slot to remove non-existing documentation from the help engine.
        """
        if HelpWindow._useQtHelp:
            for namespace in self.__helpEngine.registeredDocumentations():
                docFile = self.__helpEngine.documentationFileName(namespace)
                if not os.path.exists(docFile):
                    self.__helpEngine.unregisterDocumentation(namespace)
        
    def __lookForNewDocumentation(self):
        """
        Private slot to look for new documentation to be loaded into the
        help database.
        """
        if HelpWindow._useQtHelp:
            from .HelpDocsInstaller import HelpDocsInstaller
            self.__helpInstaller = HelpDocsInstaller(
                self.__helpEngine.collectionFile())
            self.__helpInstaller.errorMessage.connect(
                self.__showInstallationError)
            self.__helpInstaller.docsInstalled.connect(self.__docsInstalled)
            
            self.statusBar().showMessage(
                self.tr("Looking for Documentation..."))
            self.__helpInstaller.installDocs()
        
    def __showInstallationError(self, message):
        """
        Private slot to show installation errors.
        
        @param message message to be shown (string)
        """
        E5MessageBox.warning(
            self,
            self.tr("eric6 Web Browser"),
            message)
        
    def __docsInstalled(self, installed):
        """
        Private slot handling the end of documentation installation.
        
        @param installed flag indicating that documents were installed
            (boolean)
        """
        if HelpWindow._useQtHelp:
            if installed:
                self.__helpEngine.setupData()
            self.statusBar().clearMessage()
        
    def __initHelpDb(self):
        """
        Private slot to initialize the documentation database.
        """
        if HelpWindow._useQtHelp:
            if not self.__helpEngine.setupData():
                return
            
            unfiltered = self.tr("Unfiltered")
            if unfiltered not in self.__helpEngine.customFilters():
                hc = QHelpEngineCore(self.__helpEngine.collectionFile())
                hc.setupData()
                hc.addCustomFilter(unfiltered, [])
                hc = None
                del hc
                
                self.__helpEngine.blockSignals(True)
                self.__helpEngine.setCurrentFilter(unfiltered)
                self.__helpEngine.blockSignals(False)
                self.__helpEngine.setupData()
        
    def __warning(self, msg):
        """
        Private slot handling warnings from the help engine.
        
        @param msg message sent by the help  engine (string)
        """
        E5MessageBox.warning(
            self,
            self.tr("Help Engine"), msg)
        
    def __aboutToShowSettingsMenu(self):
        """
        Private slot to show the Settings menu.
        """
        self.editMessageFilterAct.setEnabled(
            E5ErrorMessage.messageHandlerInstalled())
        
    def __showBackMenu(self):
        """
        Private slot showing the backwards navigation menu.
        """
        self.backMenu.clear()
        history = self.currentBrowser().history()
        historyCount = history.count()
        backItems = history.backItems(historyCount)
        for index in range(len(backItems) - 1, -1, -1):
            item = backItems[index]
            act = QAction(self)
            act.setData(-1 * (index + 1))
            icon = HelpWindow.__getWebIcon(item.url())
            act.setIcon(icon)
            act.setText(item.title())
            self.backMenu.addAction(act)
        
    def __showForwardMenu(self):
        """
        Private slot showing the forwards navigation menu.
        """
        self.forwardMenu.clear()
        history = self.currentBrowser().history()
        historyCount = history.count()
        forwardItems = history.forwardItems(historyCount)
        for index in range(len(forwardItems)):
            item = forwardItems[index]
            act = QAction(self)
            act.setData(index + 1)
            icon = HelpWindow.__getWebIcon(item.url())
            act.setIcon(icon)
            act.setText(item.title())
            self.forwardMenu.addAction(act)
        
    def __navigationMenuActionTriggered(self, act):
        """
        Private slot to go to the selected page.
        
        @param act reference to the action selected in the navigation menu
            (QAction)
        """
        offset = act.data()
        history = self.currentBrowser().history()
        historyCount = history.count()
        if offset < 0:
            # go back
            history.goToItem(history.backItems(historyCount)[-1 * offset - 1])
        else:
            # go forward
            history.goToItem(history.forwardItems(historyCount)[offset - 1])
        
    def __clearPrivateData(self):
        """
        Private slot to clear the private data.
        """
        from .HelpClearPrivateDataDialog import HelpClearPrivateDataDialog
        dlg = HelpClearPrivateDataDialog(self)
        if dlg.exec_() == QDialog.Accepted:
            # browsing history, search history, favicons, disk cache, cookies,
            # passwords, web databases, downloads, Flash cookies
            (history, searches, favicons, cache, cookies,
             passwords, databases, downloads, flashCookies, zoomValues,
             historyPeriod) = dlg.getData()
            if history:
                self.historyManager().clear(historyPeriod)
                self.tabWidget.clearClosedTabsList()
            if searches:
                self.searchEdit.clear()
            if downloads:
                self.downloadManager().cleanup()
                self.downloadManager().hide()
            if favicons:
                self.__clearIconsDatabase()
            if cache:
                try:
                    self.networkAccessManager().cache().clear()
                except AttributeError:
                    pass
            if cookies:
                self.cookieJar().clear()
            if passwords:
                self.passwordManager().clear()
            if databases:
                if hasattr(QWebDatabase, "removeAllDatabases"):
                    QWebDatabase.removeAllDatabases()
                else:
                    for securityOrigin in QWebSecurityOrigin.allOrigins():
                        for database in securityOrigin.databases():
                            QWebDatabase.removeDatabase(database)
            if flashCookies:
                from .HelpLanguagesDialog import HelpLanguagesDialog
                languages = Preferences.toList(
                    Preferences.Prefs.settings.value(
                        "Help/AcceptLanguages",
                        HelpLanguagesDialog.defaultAcceptLanguages()))
                if languages:
                    language = languages[0]
                    langCode = language.split("[")[1][:2]
                self.newTab(
                    "http://www.macromedia.com/support/documentation/"
                    "{0}/flashplayer/help/settings_manager07.html".format(
                        langCode))
            if zoomValues:
                self.zoomManager().clear()
        
    def __showEnginesConfigurationDialog(self):
        """
        Private slot to show the search engines configuration dialog.
        """
        from .OpenSearch.OpenSearchDialog import OpenSearchDialog
        
        dlg = OpenSearchDialog(self)
        dlg.exec_()
        
    def searchEnginesAction(self):
        """
        Public method to get a reference to the search engines configuration
        action.
        
        @return reference to the search engines configuration action (QAction)
        """
        return self.searchEnginesAct
        
    def __showPasswordsDialog(self):
        """
        Private slot to show the passwords management dialog.
        """
        from .Passwords.PasswordsDialog import PasswordsDialog
        
        dlg = PasswordsDialog(self)
        dlg.exec_()
        
    def __showCertificatesDialog(self):
        """
        Private slot to show the certificates management dialog.
        """
        from E5Network.E5SslCertificatesDialog import E5SslCertificatesDialog
        
        dlg = E5SslCertificatesDialog(self)
        dlg.exec_()
        
    def __showAdBlockDialog(self):
        """
        Private slot to show the AdBlock configuration dialog.
        """
        self.adBlockManager().showDialog()
        
    def __showClickToFlashDialog(self):
        """
        Private slot to open the ClickToFlash whitelist configuration dialog.
        """
        from .HelpBrowserWV import HelpWebPage
        HelpWebPage.webPluginFactory().plugin("ClickToFlash").configure()
        
    def __showPersonalInformationDialog(self):
        """
        Private slot to show the Personal Information configuration dialog.
        """
        self.personalInformationManager().showConfigurationDialog()
        
    def __showGreaseMonkeyConfigDialog(self):
        """
        Private slot to show the GreaseMonkey scripts configuration dialog.
        """
        self.greaseMonkeyManager().showConfigurationDialog()
        
    def __showFeaturePermissionDialog(self):
        """
        Private slot to show the feature permission dialog.
        """
        self.featurePermissionManager().showFeaturePermissionsDialog()
        
    def __showZoomValuesDialog(self):
        """
        Private slot to show the zoom values management dialog.
        """
        from .ZoomManager.ZoomValuesDialog import ZoomValuesDialog
        
        dlg = ZoomValuesDialog(self)
        dlg.exec_()
        
    def __showNetworkMonitor(self):
        """
        Private slot to show the network monitor dialog.
        """
        from E5Network.E5NetworkMonitor import E5NetworkMonitor
        monitor = E5NetworkMonitor.instance(self.networkAccessManager())
        monitor.show()
        
    def __showDownloadsWindow(self):
        """
        Private slot to show the downloads dialog.
        """
        self.downloadManager().show()
        
    def __closeNetworkMonitor(self):
        """
        Private slot to close the network monitor dialog.
        """
        from E5Network.E5NetworkMonitor import E5NetworkMonitor
        E5NetworkMonitor.closeMonitor()
        
    def __showPageSource(self):
        """
        Private slot to show the source of the current page in  an editor.
        """
        from QScintilla.MiniEditor import MiniEditor
        src = self.currentBrowser().page().mainFrame().toHtml()
        editor = MiniEditor(parent=self)
        editor.setText(src, "Html")
        editor.setLanguage("dummy.html")
        editor.show()
        
    @classmethod
    def icon(cls, url):
        """
        Class method to get the icon for an URL.
        
        @param url URL to get icon for (QUrl)
        @return icon for the URL (QIcon)
        """
        icon = HelpWindow.__getWebIcon(url)
        if icon.isNull():
            hostUrl = QUrl()
            hostUrl.setScheme(url.scheme())
            hostUrl.setHost(url.host())
            icon = HelpWindow.__getWebIcon(hostUrl)
        
        if icon.isNull():
            pixmap = QWebSettings.webGraphic(
                QWebSettings.DefaultFrameIconGraphic)
            if pixmap.isNull():
                pixmap = UI.PixmapCache.getPixmap("defaultIcon.png")
                QWebSettings.setWebGraphic(
                    QWebSettings.DefaultFrameIconGraphic, pixmap)
            return QIcon(pixmap)
        
        return icon

    @staticmethod
    def __getWebIcon(url):
        """
        Private static method to fetch the icon for a URL.
        
        @param url URL to get icon for (QUrl)
        @return icon for the URL (QIcon)
        """
        scheme = url.scheme()
        if scheme in ["eric", "about"]:
            return UI.PixmapCache.getIcon("ericWeb.png")
        elif scheme == "qthelp" and QTHELP_AVAILABLE:
            return UI.PixmapCache.getIcon("qthelp.png")
        elif scheme == "file":
            return UI.PixmapCache.getIcon("fileMisc.png")
        elif scheme == "abp":
            return UI.PixmapCache.getIcon("adBlockPlus.png")
        
        icon = QWebSettings.iconForUrl(url)
        if icon.isNull():
            # try again
            QThread.usleep(10)
            icon = QWebSettings.iconForUrl(url)
        if not icon.isNull():
            icon = QIcon(icon.pixmap(22, 22))
        return icon
        
    @classmethod
    def bookmarksManager(cls):
        """
        Class method to get a reference to the bookmarks manager.
        
        @return reference to the bookmarks manager (BookmarksManager)
        """
        if cls._bookmarksManager is None:
            from .Bookmarks.BookmarksManager import BookmarksManager
            cls._bookmarksManager = BookmarksManager()
        
        return cls._bookmarksManager
        
    def openUrl(self, url, title):
        """
        Public slot to load a URL from the bookmarks menu or bookmarks toolbar
        in the current tab.
        
        @param url url to be opened (QUrl)
        @param title title of the bookmark (string)
        """
        self.__linkActivated(url)
        
    def openUrlNewTab(self, url, title):
        """
        Public slot to load a URL from the bookmarks menu or bookmarks toolbar
        in a new tab.
        
        @param url url to be opened (QUrl)
        @param title title of the bookmark (string)
        """
        req = QNetworkRequest(url)
        req.setRawHeader(b"X-Eric6-UserLoadAction", b"1")
        self.newTab(None, (req, QNetworkAccessManager.GetOperation, b""))
        
    @classmethod
    def historyManager(cls):
        """
        Class method to get a reference to the history manager.
        
        @return reference to the history manager (HistoryManager)
        """
        if cls._historyManager is None:
            from .History.HistoryManager import HistoryManager
            cls._historyManager = HistoryManager()
        
        return cls._historyManager
        
    @classmethod
    def passwordManager(cls):
        """
        Class method to get a reference to the password manager.
        
        @return reference to the password manager (PasswordManager)
        """
        if cls._passwordManager is None:
            from .Passwords.PasswordManager import PasswordManager
            cls._passwordManager = PasswordManager()
        
        return cls._passwordManager
        
    @classmethod
    def adBlockManager(cls):
        """
        Class method to get a reference to the AdBlock manager.
        
        @return reference to the AdBlock manager (AdBlockManager)
        """
        if cls._adblockManager is None:
            from .AdBlock.AdBlockManager import AdBlockManager
            cls._adblockManager = AdBlockManager()
        
        return cls._adblockManager
    
    def adBlockIcon(self):
        """
        Public method to get a reference to the AdBlock icon.
        
        @return reference to the AdBlock icon (AdBlockIcon)
        """
        return self.__adBlockIcon
    
    @classmethod
    def downloadManager(cls):
        """
        Class method to get a reference to the download manager.
        
        @return reference to the password manager (DownloadManager)
        """
        if cls._downloadManager is None:
            from .Download.DownloadManager import DownloadManager
            cls._downloadManager = DownloadManager()
        
        return cls._downloadManager
        
    @classmethod
    def personalInformationManager(cls):
        """
        Class method to get a reference to the personal information manager.
        
        @return reference to the personal information manager
            (PersonalInformationManager)
        """
        if cls._personalInformationManager is None:
            from .PersonalInformationManager.PersonalInformationManager \
                import PersonalInformationManager
            cls._personalInformationManager = PersonalInformationManager()
        
        return cls._personalInformationManager
        
    @classmethod
    def greaseMonkeyManager(cls):
        """
        Class method to get a reference to the GreaseMonkey manager.
        
        @return reference to the GreaseMonkey manager (GreaseMonkeyManager)
        """
        if cls._greaseMonkeyManager is None:
            from .GreaseMonkey.GreaseMonkeyManager import GreaseMonkeyManager
            cls._greaseMonkeyManager = GreaseMonkeyManager()
        
        return cls._greaseMonkeyManager
        
    @classmethod
    def featurePermissionManager(cls):
        """
        Class method to get a reference to the feature permission manager.
        
        @return reference to the feature permission manager
        @rtype FeaturePermissionManager
        """
        if cls._featurePermissionManager is None:
            from .FeaturePermissions.FeaturePermissionManager import \
                FeaturePermissionManager
            cls._featurePermissionManager = FeaturePermissionManager()
        
        return cls._featurePermissionManager
        
    @classmethod
    def flashCookieManager(cls):
        """
        Class method to get a reference to the flash cookies manager.
        
        @return reference to the flash cookies manager
        @rtype FlashCookieManager
        """
        if cls._flashCookieManager is None:
            from .FlashCookieManager.FlashCookieManager import \
                FlashCookieManager
            cls._flashCookieManager = FlashCookieManager()
        
        return cls._flashCookieManager
        
    @classmethod
    def zoomManager(cls):
        """
        Class method to get a reference to the zoom values manager.
        
        @return reference to the zoom values manager
        @rtype ZoomManager
        """
        if cls._zoomManager is None:
            from .ZoomManager.ZoomManager import ZoomManager
            cls._zoomManager = ZoomManager()
        
        return cls._zoomManager
        
    @classmethod
    def mainWindow(cls):
        """
        Class method to get a reference to the main window.
        
        @return reference to the main window (HelpWindow)
        """
        if cls.helpwindows:
            return cls.helpwindows[0]
        else:
            return None
        
    @classmethod
    def mainWindows(cls):
        """
        Class method to get references to all main windows.
        
        @return references to all main window (list of HelpWindow)
        """
        return cls.helpwindows
        
    def __appFocusChanged(self, old, now):
        """
        Private slot to handle a change of the focus.
        
        @param old reference to the widget, that lost focus (QWidget or None)
        @param now reference to the widget having the focus (QWidget or None)
        """
        if isinstance(now, HelpWindow):
            self.__lastActiveWindow = now
        
    def getWindow(self):
        """
        Public method to get a reference to the most recent active help window.
        
        @return reference to most recent help window
        @rtype HelpWindow
        """
        if self.__lastActiveWindow:
            return self.__lastActiveWindow
        
        return self.mainWindow()
        
    def openSearchManager(self):
        """
        Public method to get a reference to the opensearch manager object.
        
        @return reference to the opensearch manager object (OpenSearchManager)
        """
        return self.searchEdit.openSearchManager()
    
    def __createTextEncodingAction(self, codec, defaultCodec, parentMenu):
        """
        Private method to create an action for the text encoding menu.
        
        @param codec name of the codec to create an action for
        @type str
        @param defaultCodec name of the default codec
        @type str
        @param parentMenu reference to the parent menu
        @type QMenu
        """
        act = QAction(codec, parentMenu)
        act.setData(codec)
        act.setCheckable(True)
        if defaultCodec == codec:
            act.setChecked(True)
        
        parentMenu.addAction(act)
    
    def __createTextEncodingSubmenu(self, title, codecNames, parentMenu):
        """
        Private method to create a text encoding sub menu.
        
        @param title title of the menu
        @type str
        @param codecNames list of codec names for the menu
        @type list of str
        @param parentMenu reference to the parent menu
        @type QMenu
        """
        if codecNames:
            defaultCodec = \
                QWebSettings.globalSettings().defaultTextEncoding().lower()
            
            menu = QMenu(title, parentMenu)
            for codec in codecNames:
                self.__createTextEncodingAction(codec, defaultCodec, menu)
            
            parentMenu.addMenu(menu)
    
    def __aboutToShowTextEncodingMenu(self):
        """
        Private slot to populate the text encoding menu.
        """
        self.__textEncodingMenu.clear()
        
        codecs = []
        for mib in QTextCodec.availableMibs():
            codec = str(QTextCodec.codecForMib(mib).name(),
                        encoding="utf-8").lower()
            if codec not in codecs:
                codecs.append(codec)
        codecs.sort()
        
        defaultTextEncoding = \
            QWebSettings.globalSettings().defaultTextEncoding().lower()
        if defaultTextEncoding in codecs:
            currentCodec = defaultTextEncoding
        else:
            currentCodec = "system"
        
        isoCodecs = []
        winCodecs = []
        isciiCodecs = []
        uniCodecs = []
        ibmCodecs = []
        otherCodecs = []
        
        for codec in codecs:
            if codec.startswith(("iso", "latin")):
                isoCodecs.append(codec)
            elif codec.startswith(("windows")):
                winCodecs.append(codec)
            elif codec.startswith("iscii"):
                isciiCodecs.append(codec)
            elif codec.startswith("utf"):
                uniCodecs.append(codec)
            elif codec.startswith(("ibm")):
                ibmCodecs.append(codec)
            elif codec == "system":
                self.__createTextEncodingAction(codec, currentCodec,
                                                self.__textEncodingMenu)
            else:
                otherCodecs.append(codec)
        
        self.__createTextEncodingSubmenu(self.tr("ISO"), isoCodecs,
                                         self.__textEncodingMenu)
        self.__createTextEncodingSubmenu(self.tr("Unicode"), uniCodecs,
                                         self.__textEncodingMenu)
        self.__createTextEncodingSubmenu(self.tr("Windows"), winCodecs,
                                         self.__textEncodingMenu)
        self.__createTextEncodingSubmenu(self.tr("ISCII"), isciiCodecs,
                                         self.__textEncodingMenu)
        self.__createTextEncodingSubmenu(self.tr("IBM"), ibmCodecs,
                                         self.__textEncodingMenu)
        self.__createTextEncodingSubmenu(self.tr("Other"), otherCodecs,
                                         self.__textEncodingMenu)
    
    def __setTextEncoding(self, act):
        """
        Private slot to set the selected text encoding as the default for
        this session.
        
        @param act reference to the selected action (QAction)
        """
        codec = act.data()
        if codec == "":
            QWebSettings.globalSettings().setDefaultTextEncoding("")
        else:
            QWebSettings.globalSettings().setDefaultTextEncoding(codec)
    
    def eventMouseButtons(self):
        """
        Public method to get the last recorded mouse buttons.
        
        @return mouse buttons (Qt.MouseButtons)
        """
        return self.__eventMouseButtons
    
    def eventKeyboardModifiers(self):
        """
        Public method to get the last recorded keyboard modifiers.
        
        @return keyboard modifiers (Qt.KeyboardModifiers)
        """
        return self.__eventKeyboardModifiers
    
    def setEventMouseButtons(self, buttons):
        """
        Public method to record mouse buttons.
        
        @param buttons mouse buttons to record (Qt.MouseButtons)
        """
        self.__eventMouseButtons = buttons
    
    def setEventKeyboardModifiers(self, modifiers):
        """
        Public method to record keyboard modifiers.
        
        @param modifiers keyboard modifiers to record (Qt.KeyboardModifiers)
        """
        self.__eventKeyboardModifiers = modifiers
    
    def mousePressEvent(self, evt):
        """
        Protected method called by a mouse press event.
        
        @param evt reference to the mouse event (QMouseEvent)
        """
        if evt.button() == Qt.XButton1:
            self.currentBrowser().pageAction(QWebPage.Back).trigger()
        elif evt.button() == Qt.XButton2:
            self.currentBrowser().pageAction(QWebPage.Forward).trigger()
        else:
            super(HelpWindow, self).mousePressEvent(evt)

    @classmethod
    def feedsManager(cls):
        """
        Class method to get a reference to the RSS feeds manager.
        
        @return reference to the RSS feeds manager (FeedsManager)
        """
        if cls._feedsManager is None:
            from .Feeds.FeedsManager import FeedsManager
            cls._feedsManager = FeedsManager()
        
        return cls._feedsManager
    
    def __showFeedsManager(self):
        """
        Private slot to show the feeds manager dialog.
        """
        feedsManager = self.feedsManager()
        feedsManager.openUrl.connect(self.openUrl)
        feedsManager.newUrl.connect(self.openUrlNewTab)
        feedsManager.rejected.connect(
            lambda fm: self.__feedsManagerClosed(fm))
        feedsManager.show()
    
    def __feedsManagerClosed(self, feedsManager):
        """
        Private slot to handle closing the feeds manager dialog.
        
        @param feedsManager reference to the feeds manager object
        @type FeedsManager
        """
        feedsManager.openUrl.disconnect(self.openUrl)
        feedsManager.newUrl.disconnect(self.openUrlNewTab)
        feedsManager.rejected.disconnect()
    
    def __showSiteinfoDialog(self):
        """
        Private slot to show the site info dialog.
        """
        from .SiteInfo.SiteInfoDialog import SiteInfoDialog
        self.__siteinfoDialog = SiteInfoDialog(self.currentBrowser(), self)
        self.__siteinfoDialog.show()

    @classmethod
    def userAgentsManager(cls):
        """
        Class method to get a reference to the user agents manager.
        
        @return reference to the user agents manager (UserAgentManager)
        """
        if cls._userAgentsManager is None:
            from .UserAgent.UserAgentManager import UserAgentManager
            cls._userAgentsManager = UserAgentManager()
        
        return cls._userAgentsManager
    
    def __showUserAgentsDialog(self):
        """
        Private slot to show the user agents management dialog.
        """
        from .UserAgent.UserAgentsDialog import UserAgentsDialog
        
        dlg = UserAgentsDialog(self)
        dlg.exec_()
    
    @classmethod
    def syncManager(cls):
        """
        Class method to get a reference to the data synchronization manager.
        
        @return reference to the data synchronization manager (SyncManager)
        """
        if cls._syncManager is None:
            from .Sync.SyncManager import SyncManager
            cls._syncManager = SyncManager()
        
        return cls._syncManager
    
    def __showSyncDialog(self):
        """
        Private slot to show the synchronization dialog.
        """
        self.syncManager().showSyncDialog()
    
    @classmethod
    def speedDial(cls):
        """
        Class methdo to get a reference to the speed dial.
        
        @return reference to the speed dial (SpeedDial)
        """
        if cls._speedDial is None:
            from .SpeedDial.SpeedDial import SpeedDial
            cls._speedDial = SpeedDial()
        
        return cls._speedDial
    
    def keyPressEvent(self, evt):
        """
        Protected method to handle key presses.
        
        @param evt reference to the key press event (QKeyEvent)
        """
        number = -1
        key = evt.key()
        
        if key == Qt.Key_1:
            number = 1
        elif key == Qt.Key_2:
            number = 2
        elif key == Qt.Key_3:
            number = 3
        elif key == Qt.Key_4:
            number = 4
        elif key == Qt.Key_5:
            number = 5
        elif key == Qt.Key_6:
            number = 6
        elif key == Qt.Key_7:
            number = 7
        elif key == Qt.Key_8:
            number = 8
        elif key == Qt.Key_9:
            number = 9
        elif key == Qt.Key_0:
            number = 10
        
        if number != -1:
            if evt.modifiers() == Qt.KeyboardModifiers(Qt.AltModifier):
                if number == 10:
                    number = self.tabWidget.count()
                self.tabWidget.setCurrentIndex(number - 1)
                return
            
            if evt.modifiers() == Qt.KeyboardModifiers(Qt.MetaModifier):
                url = self.speedDial().urlForShortcut(number - 1)
                if url.isValid():
                    self.__linkActivated(url)
                    return
        
        super(HelpWindow, self).keyPressEvent(evt)
    
    ###########################################################################
    ## Interface to VirusTotal below                                         ##
    ###########################################################################
    
    def __virusTotalScanCurrentSite(self):
        """
        Private slot to ask VirusTotal for a scan of the URL of the current
        browser.
        """
        cb = self.currentBrowser()
        if cb is not None:
            url = cb.url()
            if url.scheme() in ["http", "https", "ftp"]:
                self.requestVirusTotalScan(url)
    
    def requestVirusTotalScan(self, url):
        """
        Public method to submit a request to scan an URL by VirusTotal.
        
        @param url URL to be scanned (QUrl)
        """
        self.__virusTotal.submitUrl(url)
    
    def __virusTotalSubmitUrlError(self, msg):
        """
        Private slot to handle an URL scan submission error.
        
        @param msg error message (str)
        """
        E5MessageBox.critical(
            self,
            self.tr("VirusTotal Scan"),
            self.tr("""<p>The VirusTotal scan could not be"""
                    """ scheduled.<p>\n<p>Reason: {0}</p>""").format(msg))
    
    def __virusTotalUrlScanReport(self, url):
        """
        Private slot to initiate the display of the URL scan report page.
        
        @param url URL of the URL scan report page (string)
        """
        self.newTab(url)
    
    def __virusTotalFileScanReport(self, url):
        """
        Private slot to initiate the display of the file scan report page.
        
        @param url URL of the file scan report page (string)
        """
        self.newTab(url)
    
    def __virusTotalIpAddressReport(self):
        """
        Private slot to retrieve an IP address report.
        """
        ip, ok = QInputDialog.getText(
            self,
            self.tr("IP Address Report"),
            self.tr("Enter a valid IPv4 address in dotted quad notation:"),
            QLineEdit.Normal)
        if ok and ip:
            if ip.count(".") == 3:
                self.__virusTotal.getIpAddressReport(ip)
            else:
                E5MessageBox.information(
                    self,
                    self.tr("IP Address Report"),
                    self.tr("""The given IP address is not in dotted quad"""
                            """ notation."""))
    
    def __virusTotalDomainReport(self):
        """
        Private slot to retrieve a domain report.
        """
        domain, ok = QInputDialog.getText(
            self,
            self.tr("Domain Report"),
            self.tr("Enter a valid domain name:"),
            QLineEdit.Normal)
        if ok and domain:
            self.__virusTotal.getDomainReport(domain)
    
    ###########################################################################
    ## Style sheet handling below                                            ##
    ###########################################################################
    
    def reloadUserStyleSheet(self):
        """
        Public method to reload the user style sheet.
        """
        settings = QWebSettings.globalSettings()
        styleSheet = Preferences.getHelp("UserStyleSheet")
        settings.setUserStyleSheetUrl(self.__userStyleSheet(styleSheet))
    
    def __userStyleSheet(self, styleSheetFile):
        """
        Private method to generate the user style sheet.
        
        @param styleSheetFile name of the user style sheet file (string)
        @return style sheet (QUrl)
        """
        userStyle = self.adBlockManager().elementHidingRules() + \
            "{display:none !important;}"
        
        if styleSheetFile:
            try:
                f = open(styleSheetFile, "r")
                fileData = f.read()
                f.close()
                fileData = fileData.replace("\n", "")
                userStyle += fileData
            except IOError:
                pass
        
        encodedStyle = bytes(QByteArray(userStyle.encode("utf-8")).toBase64())\
            .decode()
        dataString = "data:text/css;charset=utf-8;base64,{0}".format(
            encodedStyle)
        
        return QUrl(dataString)
    
    ##########################################
    ## Support for desktop notifications below
    ##########################################
    
    @classmethod
    def showNotification(cls, icon, heading, text):
        """
        Class method to show a desktop notification.
        
        @param icon icon to be shown in the notification (QPixmap)
        @param heading heading of the notification (string)
        @param text text of the notification (string)
        """
        if Preferences.getUI("NotificationsEnabled"):
            if cls._notification is None:
                from UI.NotificationWidget import NotificationWidget
                cls._notification = NotificationWidget()
            cls._notification.setPixmap(icon)
            cls._notification.setHeading(heading)
            cls._notification.setText(text)
            cls._notification.setTimeout(
                Preferences.getUI("NotificationTimeout"))
            cls._notification.move(
                Preferences.getUI("NotificationPosition"))
            cls._notification.show()
    
    @classmethod
    def notificationsEnabled(cls):
        """
        Class method to check, if notifications are enabled.
        
        @return flag indicating, if notifications are enabled (boolean)
        """
        return Preferences.getUI("NotificationsEnabled")
    
    ###############################################################
    ## Methods below implement single application related functions
    ###############################################################
    
    @pyqtSlot(str)
    def __saLoadUrl(self, urlStr):
        """
        Private slot to load an URL received via the single application
        protocol.
        
        @param urlStr URL to be loaded
        @type str
        """
        url = QUrl.fromUserInput(urlStr)
        self.__linkActivated(url)
    
    @pyqtSlot(str)
    def __saNewTab(self, urlStr):
        """
        Private slot to load an URL received via the single application
        protocol in a new tab.
        
        @param urlStr URL to be loaded
        @type str
        """
        url = QUrl.fromUserInput(urlStr)
        self.newTab(url)
    
    @pyqtSlot(str)
    def __saSearchWord(self, word):
        """
        Private slot to search for the given word.
        
        @param word word to be searched for
        @type str
        """
        if HelpWindow._useQtHelp:
            self.__searchWord = word
            self.__searchForWord()
    
    ######################################################
    ## Methods below implement shortcuts related functions
    ######################################################
    
    def __configShortcuts(self):
        """
        Private slot to configure the keyboard shortcuts.
        """
        if self.__shortcutsDialog is None:
            from Preferences.ShortcutsDialog import ShortcutsDialog
            self.__shortcutsDialog = ShortcutsDialog(self)
        self.__shortcutsDialog.populate(helpViewer=self)
        self.__shortcutsDialog.show()
    
    def __exportShortcuts(self):
        """
        Private slot to export the keyboard shortcuts.
        """
        fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
            None,
            self.tr("Export Keyboard Shortcuts"),
            "",
            self.tr("Keyboard shortcut file (*.e4k)"),
            "",
            E5FileDialog.Options(E5FileDialog.DontConfirmOverwrite))
        
        if not fn:
            return
        
        ext = QFileInfo(fn).suffix()
        if not ext:
            ex = selectedFilter.split("(*")[1].split(")")[0]
            if ex:
                fn += ex
        
        from Preferences import Shortcuts
        Shortcuts.exportShortcuts(fn, helpViewer=self)

    def __importShortcuts(self):
        """
        Private slot to import the keyboard shortcuts.
        """
        fn = E5FileDialog.getOpenFileName(
            None,
            self.tr("Import Keyboard Shortcuts"),
            "",
            self.tr("Keyboard shortcut file (*.e4k)"))
        
        if fn:
            from Preferences import Shortcuts
            Shortcuts.importShortcuts(fn, helpViewer=self)
