diff -r f99d60d6b59b -r 2602857055c5 eric6/Helpviewer/HelpWindow.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/eric6/Helpviewer/HelpWindow.py Sun Apr 14 15:09:21 2019 +0200
@@ -0,0 +1,4022 @@
+# -*- 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)
