eric: comparison eric6/Helpviewer/HelpWindow.py

-:f99d60d6b59b
+:2602857055c5
+# -*- 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)

Mercurial Repositories > eric / file comparison

comparison: eric6/Helpviewer/HelpWindow.py

eric6/Helpviewer/HelpWindow.py