eric: comparison Helpviewer/HelpWindow.py

-:9986ec0e559a
+:10516539f238
 except (NameError):
 pass
 import os
-from PyQt4.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QSize, QTimer, QUrl, \
+from PyQt4.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QSize, QTimer, \
-QThread, QTextCodec
+QUrl, QThread, QTextCodec
 from PyQt4.QtGui import QWidget, QVBoxLayout, QSizePolicy, QDockWidget, \
 QDesktopServices, QKeySequence, QComboBox, QFont, QFontMetrics, QLabel, \
-QSplitter, QMenu, QToolButton, QLineEdit, QApplication, QWhatsThis, QDialog, \
+QSplitter, QMenu, QToolButton, QLineEdit, QApplication, QWhatsThis, \
-QHBoxLayout, QProgressBar, QAction, QIcon
+QDialog, QHBoxLayout, QProgressBar, QAction, QIcon
 from PyQt4.QtNetwork import QNetworkAccessManager, QNetworkRequest
-from PyQt4.QtWebKit import QWebSettings, QWebDatabase, QWebSecurityOrigin, QWebPage
+from PyQt4.QtWebKit import QWebSettings, QWebDatabase, QWebSecurityOrigin, \
+QWebPage
 try:
 from PyQt4.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
 QTHELP_AVAILABLE = True
 except ImportError:
 QTHELP_AVAILABLE = False
 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
+@signal zoomTextOnlyChanged(bool) emitted after the zoom text only setting
-changed
+was changed
 """
 zoomTextOnlyChanged = pyqtSignal(bool)
 helpClosed = pyqtSignal()
 privacyChanged = pyqtSignal(bool)
 @param home the URL to be shown (string)
 @param path the path of the working dir (usually '.') (string)
 @param parent parent widget of this window (QWidget)
 @param name name of this window (string)
-@param fromEric flag indicating whether it was called from within eric5 (boolean)
+@param fromEric flag indicating whether it was called from within
-@keyparam initShortcutsOnly flag indicating to just initialize the keyboard
+eric5 (boolean)
-shortcuts (boolean)
+@keyparam initShortcutsOnly flag indicating to just initialize the
+keyboard shortcuts (boolean)
 @keyparam searchWord word to search for (string)
 """
 super(HelpWindow, self).__init__(parent)
 self.setObjectName(name)
 self.setWindowTitle(self.trUtf8("eric5 Web Browser"))
 from .VirusTotalApi import VirusTotalAPI
 HelpWindow.setUseQtHelp(self.fromEric)
 if not self.fromEric:
-self.setStyle(Preferences.getUI("Style"), Preferences.getUI("StyleSheet"))
+self.setStyle(Preferences.getUI("Style"),
+Preferences.getUI("StyleSheet"))
 if self.useQtHelp:
 self.__helpEngine = \
 QHelpEngine(os.path.join(Utilities.getConfigDir(),
 "browser", "eric5help.qhc"), self)
 self.__helpEngine.warning.connect(self.__warning)
 else:
 self.__helpEngine = None
 self.__helpInstaller = None
-self.__zoomWidget = E5ZoomWidget(UI.PixmapCache.getPixmap("zoomOut.png"),
+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.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.browserClosed.connect(self.__browserClosed)
-self.tabWidget.browserZoomValueChanged.connect(self.__zoomWidget.setValue)
+self.tabWidget.browserZoomValueChanged.connect(
+self.__zoomWidget.setValue)
 self.findDlg = SearchWidget(self, self)
 centralWidget = QWidget()
 layout = QVBoxLayout()
 layout.setContentsMargins(1, 1, 1, 1)
 # 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.indexingStarted.connect(
-self.__searchEngine.indexingFinished.connect(self.__indexingFinished)
+self.__indexingStarted)
-self.__searchWindow = HelpSearchWidget(self.__searchEngine, self)
+self.__searchEngine.indexingFinished.connect(
+self.__indexingFinished)
+self.__searchWindow = HelpSearchWidget(
+self.__searchEngine, self)
 self.__searchDock = QDockWidget(self.trUtf8("Search"), self)
 self.__searchDock.setObjectName("SearchWindow")
 self.__searchDock.setWidget(self.__searchWindow)
 self.addDockWidget(Qt.LeftDockWidgetArea, self.__searchDock)
 self.__class__.helpwindows.append(self)
 self.__adBlockIcon = AdBlockIcon(self)
 self.statusBar().addPermanentWidget(self.__adBlockIcon)
-self.__adBlockIcon.setEnabled(Preferences.getHelp("AdBlockEnabled"))
+self.__adBlockIcon.setEnabled(
-self.tabWidget.currentChanged[int].connect(self.__adBlockIcon.currentChanged)
+Preferences.getHelp("AdBlockEnabled"))
-self.tabWidget.sourceChanged.connect(self.__adBlockIcon.sourceChanged)
+self.tabWidget.currentChanged[int].connect(
+self.__adBlockIcon.currentChanged)
+self.tabWidget.sourceChanged.connect(
+self.__adBlockIcon.sourceChanged)
 QDesktopServices.setUrlHandler("http", self.__linkActivated)
 QDesktopServices.setUrlHandler("https", self.__linkActivated)
 # setup connections
 self.__activating = False
 if self.useQtHelp:
 # TOC window
 self.__tocWindow.linkActivated.connect(self.__linkActivated)
-self.__tocWindow.escapePressed.connect(self.__activateCurrentBrowser)
+self.__tocWindow.escapePressed.connect(
+self.__activateCurrentBrowser)
 # index window
 self.__indexWindow.linkActivated.connect(self.__linkActivated)
-self.__indexWindow.linksActivated.connect(self.__linksActivated)
+self.__indexWindow.linksActivated.connect(
-self.__indexWindow.escapePressed.connect(self.__activateCurrentBrowser)
+self.__linksActivated)
+self.__indexWindow.escapePressed.connect(
+self.__activateCurrentBrowser)
 # search window
-self.__searchWindow.linkActivated.connect(self.__linkActivated)
+self.__searchWindow.linkActivated.connect(
-self.__searchWindow.escapePressed.connect(self.__activateCurrentBrowser)
+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.submitUrlError.connect(
-self.__virusTotal.urlScanReport.connect(self.__virusTotalUrlScanReport)
+self.__virusTotalSubmitUrlError)
-self.__virusTotal.fileScanReport.connect(self.__virusTotalFileScanReport)
+self.__virusTotal.urlScanReport.connect(
+self.__virusTotalUrlScanReport)
+self.__virusTotal.fileScanReport.connect(
+self.__virusTotalFileScanReport)
 self.__previewer = None
 self.__shutdownCalled = False
 if self.useQtHelp:
 fixedFont = Preferences.getHelp("FixedFont")
 settings = QWebSettings.globalSettings()
 settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
-settings.setFontFamily(QWebSettings.StandardFont, standardFont.family())
+settings.setFontFamily(QWebSettings.StandardFont,
-settings.setFontSize(QWebSettings.DefaultFontSize, standardFont.pointSize())
+standardFont.family())
+settings.setFontSize(QWebSettings.DefaultFontSize,
+standardFont.pointSize())
 settings.setFontFamily(QWebSettings.FixedFont, fixedFont.family())
-settings.setFontSize(QWebSettings.DefaultFixedFontSize, fixedFont.pointSize())
+settings.setFontSize(QWebSettings.DefaultFixedFontSize,
+fixedFont.pointSize())
 styleSheet = Preferences.getHelp("UserStyleSheet")
 settings.setUserStyleSheetUrl(self.__userStyleSheet(styleSheet))
 settings.setAttribute(QWebSettings.AutoLoadImages,
 Utilities.getConfigDir(), "browser", "webdatabases")
 if not os.path.exists(webDatabaseDir):
 os.makedirs(webDatabaseDir)
 settings.setOfflineStoragePath(webDatabaseDir)
 settings.setOfflineStorageDefaultQuota(
-Preferences.getHelp("OfflineStorageDatabaseQuota") * 1024 * 1024)
+Preferences.getHelp("OfflineStorageDatabaseQuota") * \
+1024 * 1024)
 if hasattr(QWebSettings, "OfflineWebApplicationCacheEnabled"):
-settings.setAttribute(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)
+Preferences.getHelp("OfflineWebApplicationCacheQuota") * \
+1024 * 1024)
 if hasattr(QWebSettings, "LocalStorageEnabled"):
 settings.setAttribute(QWebSettings.LocalStorageEnabled,
 Preferences.getHelp("LocalStorageEnabled"))
 localStorageDir = os.path.join(
 ))
 if not self.initShortcutsOnly:
 self.savePageScreenAct.triggered[()].connect(self.__savePageScreen)
 self.__actions.append(self.savePageScreenAct)
-self.saveVisiblePageScreenAct = E5Action(self.trUtf8('Save Visible Page Screen'),
+self.saveVisiblePageScreenAct = E5Action(
+self.trUtf8('Save Visible Page Screen'),
 UI.PixmapCache.getIcon("fileSaveVisiblePixmap.png"),
 self.trUtf8('Save Visible Page Screen...'),
 0, 0, self, 'help_file_save_visible_page_screen')
 self.saveVisiblePageScreenAct.setStatusTip(
-self.trUtf8('Save the visible part of the current page as a screen shot'))
+self.trUtf8('Save the visible part of the current page as a'
+' screen shot'))
 self.saveVisiblePageScreenAct.setWhatsThis(self.trUtf8(
 """<b>Save Visible Page Screen...</b>"""
-"""<p>Saves the visible part of the current page as a screen shot.</p>"""
+"""<p>Saves the visible part of the current page as a"""
+""" screen shot.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.saveVisiblePageScreenAct.triggered[()].connect(
 self.__saveVisiblePageScreen)
 self.__actions.append(self.saveVisiblePageScreenAct)
 self.printPdfAct = E5Action(self.trUtf8('Print as PDF'),
 UI.PixmapCache.getIcon("printPdf.png"),
 self.trUtf8('Print as PDF'),
 0, 0, self, 'help_file_print_pdf')
-self.printPdfAct.setStatusTip(self.trUtf8('Print the displayed help as PDF'))
+self.printPdfAct.setStatusTip(self.trUtf8(
+'Print the displayed help as PDF'))
 self.printPdfAct.setWhatsThis(self.trUtf8(
 """<b>Print as PDF</b>"""
 """<p>Print the displayed help text as a PDF file.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.printPdfAct.triggered[()].connect(self.tabWidget.printBrowserPdf)
+self.printPdfAct.triggered[()].connect(
+self.tabWidget.printBrowserPdf)
 self.__actions.append(self.printPdfAct)
 self.printPreviewAct = E5Action(self.trUtf8('Print Preview'),
 UI.PixmapCache.getIcon("printPreview.png"),
 self.trUtf8('Print Preview'),
 self.printPreviewAct.setWhatsThis(self.trUtf8(
 """<b>Print Preview</b>"""
 """<p>Print preview of the displayed help text.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.printPreviewAct.triggered[()].connect(self.tabWidget.printPreviewBrowser)
+self.printPreviewAct.triggered[()].connect(
+self.tabWidget.printPreviewBrowser)
 self.__actions.append(self.printPreviewAct)
 self.closeAct = E5Action(self.trUtf8('Close'),
 UI.PixmapCache.getIcon("close.png"),
 self.trUtf8('&Close'),
 QKeySequence(self.trUtf8("Ctrl+W", "File|Close")),
 0, self, 'help_file_close')
-self.closeAct.setStatusTip(self.trUtf8('Close the current help window'))
+self.closeAct.setStatusTip(self.trUtf8(
+'Close the current help window'))
 self.closeAct.setWhatsThis(self.trUtf8(
 """<b>Close</b>"""
 """<p>Closes the current help window.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.closeAct.triggered[()].connect(self.tabWidget.closeBrowser)
 self.__actions.append(self.closeAct)
 self.closeAllAct.setWhatsThis(self.trUtf8(
 """<b>Close All</b>"""
 """<p>Closes all help windows except the first one.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.closeAllAct.triggered[()].connect(self.tabWidget.closeAllBrowsers)
+self.closeAllAct.triggered[()].connect(
+self.tabWidget.closeAllBrowsers)
 self.__actions.append(self.closeAllAct)
 self.privateBrowsingAct = E5Action(self.trUtf8('Private Browsing'),
 UI.PixmapCache.getIcon("privateBrowsing.png"),
 self.trUtf8('Private &Browsing'),
 """<b>Private Browsing</b>"""
 """<p>Enables private browsing. In this mode no history is"""
 """ recorded anymore.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.privateBrowsingAct.triggered[()].connect(self.__privateBrowsing)
+self.privateBrowsingAct.triggered[()].connect(
+self.__privateBrowsing)
 self.privateBrowsingAct.setCheckable(True)
 self.__actions.append(self.privateBrowsingAct)
 self.exitAct = E5Action(self.trUtf8('Quit'),
 UI.PixmapCache.getIcon("exit.png"),
 UI.PixmapCache.getIcon("forward.png"),
 self.trUtf8('&Forward'),
 QKeySequence(self.trUtf8("Alt+Right", "Go|Forward")),
 QKeySequence(self.trUtf8("Shift+Backspace", "Go|Forward")),
 self, 'help_go_foreward')
-self.forwardAct.setStatusTip(self.trUtf8('Move one help screen forward'))
+self.forwardAct.setStatusTip(self.trUtf8(
+'Move one help screen forward'))
 self.forwardAct.setWhatsThis(self.trUtf8(
 """<b>Forward</b>"""
 """<p>Moves one help screen forward. If none is"""
 """ available, this action is disabled.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.forwardAct.triggered[()].connect(self.__forward)
 self.__actions.append(self.forwardAct)
 self.homeAct = E5Action(self.trUtf8('Home'),
 UI.PixmapCache.getIcon("home.png"),
 self.trUtf8('&Home'),
 QKeySequence(self.trUtf8("Ctrl+Home", "Go|Home")),
 0, self, 'help_go_home')
-self.homeAct.setStatusTip(self.trUtf8('Move to the initial help screen'))
+self.homeAct.setStatusTip(self.trUtf8(
+'Move to the initial help screen'))
 self.homeAct.setWhatsThis(self.trUtf8(
 """<b>Home</b>"""
 """<p>Moves to the initial help screen.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.homeAct.triggered[()].connect(self.__home)
 self.__actions.append(self.homeAct)
 UI.PixmapCache.getIcon("reload.png"),
 self.trUtf8('&Reload'),
 QKeySequence(self.trUtf8("Ctrl+R", "Go|Reload")),
 QKeySequence(self.trUtf8("F5", "Go|Reload")),
 self, 'help_go_reload')
-self.reloadAct.setStatusTip(self.trUtf8('Reload the current help screen'))
+self.reloadAct.setStatusTip(self.trUtf8(
+'Reload the current help screen'))
 self.reloadAct.setWhatsThis(self.trUtf8(
 """<b>Reload</b>"""
 """<p>Reloads the current help screen.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.reloadAct.triggered[()].connect(self.__reload)
 self.__actions.append(self.reloadAct)
 self.findNextAct = E5Action(self.trUtf8('Find next'),
 UI.PixmapCache.getIcon("findNext.png"),
 self.trUtf8('Find &next'),
 QKeySequence(self.trUtf8("F3", "Edit|Find next")),
 0, self, 'help_edit_find_next')
-self.findNextAct.setStatusTip(self.trUtf8('Find next occurrence of text in page'))
+self.findNextAct.setStatusTip(self.trUtf8(
+'Find next occurrence of text in page'))
 self.findNextAct.setWhatsThis(self.trUtf8(
 """<b>Find next</b>"""
 """<p>Find the next occurrence of text in the current page.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.findNextAct.triggered[()].connect(self.findDlg.findNext)
 self.__actions.append(self.findNextAct)
 QKeySequence(self.trUtf8("Shift+F3", "Edit|Find previous")),
 0, self, 'help_edit_find_previous')
 self.findPrevAct.setStatusTip(
 self.trUtf8('Find previous occurrence of text in page'))
 self.findPrevAct.setWhatsThis(self.trUtf8(
 """<b>Find previous</b>"""
-"""<p>Find the previous occurrence of text in the current page.</p>"""
+"""<p>Find the previous occurrence of text in the current"""
+""" page.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.findPrevAct.triggered[()].connect(self.findDlg.findPrevious)
 self.__actions.append(self.findPrevAct)
 self.bookmarksManageAct.setWhatsThis(self.trUtf8(
 """<b>Manage Bookmarks...</b>"""
 """<p>Open a dialog to manage the bookmarks.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.bookmarksManageAct.triggered[()].connect(self.__showBookmarksDialog)
+self.bookmarksManageAct.triggered[()].connect(
+self.__showBookmarksDialog)
 self.__actions.append(self.bookmarksManageAct)
 self.bookmarksAddAct = E5Action(self.trUtf8('Add Bookmark'),
 UI.PixmapCache.getIcon("addBookmark.png"),
 self.trUtf8('Add &Bookmark...'),
 QKeySequence(self.trUtf8("Ctrl+D", "Help|Add bookmark")),
 0, self, 'help_bookmark_add')
 self.bookmarksAddAct.setIconVisibleInMenu(False)
-self.bookmarksAddAct.setStatusTip(self.trUtf8('Open a dialog to add a bookmark.'))
+self.bookmarksAddAct.setStatusTip(self.trUtf8(
+'Open a dialog to add a bookmark.'))
 self.bookmarksAddAct.setWhatsThis(self.trUtf8(
 """<b>Add Bookmark</b>"""
 """<p>Open a dialog to add the current URL as a bookmark.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.bookmarksAddAct.triggered[()].connect(self.__addBookmark)
 self.__actions.append(self.bookmarksAddAct)
 self.bookmarksAddFolderAct.setWhatsThis(self.trUtf8(
 """<b>Add Folder...</b>"""
 """<p>Open a dialog to add a new bookmarks folder.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.bookmarksAddFolderAct.triggered[()].connect(self.__addBookmarkFolder)
+self.bookmarksAddFolderAct.triggered[()].connect(
+self.__addBookmarkFolder)
 self.__actions.append(self.bookmarksAddFolderAct)
 self.bookmarksAllTabsAct = E5Action(self.trUtf8('Bookmark All Tabs'),
 self.trUtf8('Bookmark All Tabs...'),
 0, 0, self, 'help_bookmark_all_tabs')
 self.trUtf8('&What\'s This?'),
 QKeySequence(self.trUtf8("Shift+F1", "Help|What's This?'")),
 0, self, 'help_help_whats_this')
 self.whatsThisAct.setStatusTip(self.trUtf8('Context sensitive help'))
 self.whatsThisAct.setWhatsThis(self.trUtf8(
 """<b>Display context sensitive help</b>"""
-"""<p>In What's This? mode, the mouse cursor shows an arrow with a"""
+"""<p>In What's This? mode, the mouse cursor shows an arrow"""
-""" question mark, and you can click on the interface elements to get"""
+""" with a question mark, and you can click on the interface"""
-""" a short description of what they do and how to use them. In"""
+""" elements to get a short description of what they do and how"""
-""" dialogs, this feature can be accessed using the context help button"""
+""" to use them. In dialogs, this feature can be accessed using"""
-""" in the titlebar.</p>"""
+""" the context help button in the titlebar.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.whatsThisAct.triggered[()].connect(self.__whatsThis)
 self.__actions.append(self.whatsThisAct)
 self.aboutAct = E5Action(self.trUtf8('About'),
 self.trUtf8('&About'),
 0, 0, self, 'help_help_about')
-self.aboutAct.setStatusTip(self.trUtf8('Display information about this software'))
+self.aboutAct.setStatusTip(self.trUtf8(
+'Display information about this software'))
 self.aboutAct.setWhatsThis(self.trUtf8(
 """<b>About</b>"""
 """<p>Display some information about this software.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.aboutAct.triggered[()].connect(self.__about)
 self.__actions.append(self.aboutAct)
 self.zoomResetAct = E5Action(self.trUtf8('Zoom reset'),
 UI.PixmapCache.getIcon("zoomReset.png"),
 self.trUtf8('Zoom &reset'),
 QKeySequence(self.trUtf8("Ctrl+0", "View|Zoom reset")),
 0, self, 'help_view_zoom_reset')
-self.zoomResetAct.setStatusTip(self.trUtf8('Reset the zoom of the text'))
+self.zoomResetAct.setStatusTip(self.trUtf8(
+'Reset the zoom of the text'))
 self.zoomResetAct.setWhatsThis(self.trUtf8(
 """<b>Zoom reset</b>"""
 """<p>Reset the zoom of the text. """
 """This sets the zoom factor to 100%.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.zoomResetAct.triggered[()].connect(self.__zoomReset)
 self.__actions.append(self.zoomResetAct)
 self.zoomTextOnlyAct.setWhatsThis(self.trUtf8(
 """<b>Zoom text only</b>"""
 """<p>Zoom text only; pictures remain constant.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.zoomTextOnlyAct.triggered[bool].connect(self.__zoomTextOnly)
+self.zoomTextOnlyAct.triggered[bool].connect(
+self.__zoomTextOnly)
 self.__actions.append(self.zoomTextOnlyAct)
 else:
 self.zoomTextOnlyAct = None
 self.pageSourceAct = E5Action(self.trUtf8('Show page source'),
 self.trUtf8('Show page source'),
 QKeySequence(self.trUtf8('Ctrl+U')), 0,
 self, 'help_show_page_source')
-self.pageSourceAct.setStatusTip(self.trUtf8('Show the page source in an editor'))
+self.pageSourceAct.setStatusTip(self.trUtf8(
+'Show the page source in an editor'))
 self.pageSourceAct.setWhatsThis(self.trUtf8(
 """<b>Show page source</b>"""
 """<p>Show the page source in an editor.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.pageSourceAct.triggered[()].connect(self.__showPageSource)
 self.__actions.append(self.pageSourceAct)
 self.addAction(self.pageSourceAct)
 self.addAction(self.switchTabAct)
 self.prefAct = E5Action(self.trUtf8('Preferences'),
 UI.PixmapCache.getIcon("configure.png"),
 self.trUtf8('&Preferences...'), 0, 0, self, 'help_preferences')
-self.prefAct.setStatusTip(self.trUtf8('Set the prefered configuration'))
+self.prefAct.setStatusTip(self.trUtf8(
+'Set the prefered configuration'))
 self.prefAct.setWhatsThis(self.trUtf8(
 """<b>Preferences</b>"""
 """<p>Set the configuration items of the application"""
 """ with your prefered values.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.prefAct.triggered[()].connect(self.__showPreferences)
 self.__actions.append(self.prefAct)
-self.acceptedLanguagesAct = E5Action(self.trUtf8('Languages'),
+self.acceptedLanguagesAct = E5Action(
+self.trUtf8('Languages'),
 UI.PixmapCache.getIcon("flag.png"),
-self.trUtf8('&Languages...'), 0, 0, self, 'help_accepted_languages')
+self.trUtf8('&Languages...'), 0, 0,
+self, 'help_accepted_languages')
 self.acceptedLanguagesAct.setStatusTip(self.trUtf8(
 'Configure the accepted languages for web pages'))
 self.acceptedLanguagesAct.setWhatsThis(self.trUtf8(
 """<b>Languages</b>"""
 """<p>Configure the accepted languages for web pages.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.acceptedLanguagesAct.triggered[()].connect(self.__showAcceptedLanguages)
+self.acceptedLanguagesAct.triggered[()].connect(
+self.__showAcceptedLanguages)
 self.__actions.append(self.acceptedLanguagesAct)
 self.cookiesAct = E5Action(self.trUtf8('Cookies'),
 UI.PixmapCache.getIcon("cookie.png"),
 self.trUtf8('C&ookies...'), 0, 0, self, 'help_cookies')
 self.cookiesAct.setWhatsThis(self.trUtf8(
 """<b>Cookies</b>"""
 """<p>Configure cookies handling.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.cookiesAct.triggered[()].connect(self.__showCookiesConfiguration)
+self.cookiesAct.triggered[()].connect(
+self.__showCookiesConfiguration)
 self.__actions.append(self.cookiesAct)
 self.offlineStorageAct = E5Action(self.trUtf8('Offline Storage'),
 UI.PixmapCache.getIcon("preferences-html5.png"),
-self.trUtf8('Offline &Storage...'), 0, 0, self, 'help_offline_storage')
+self.trUtf8('Offline &Storage...'), 0, 0,
+self, 'help_offline_storage')
 self.offlineStorageAct.setStatusTip(self.trUtf8(
 'Configure offline storage'))
 self.offlineStorageAct.setWhatsThis(self.trUtf8(
 """<b>Offline Storage</b>"""
 """<p>Opens a dialog to configure offline storage.</p>"""
 self, 'help_personal_information')
 self.personalDataAct.setStatusTip(self.trUtf8(
 'Configure personal information for completing form fields'))
 self.personalDataAct.setWhatsThis(self.trUtf8(
 """<b>Personal Information...</b>"""
-"""<p>Opens a dialog to configure the personal information used for"""
+"""<p>Opens a dialog to configure the personal information"""
-""" completing form fields.</p>"""
+""" used for completing form fields.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.personalDataAct.triggered[()].connect(
 self.__showPersonalInformationDialog)
 self.__actions.append(self.personalDataAct)
 self, 'help_greasemonkey')
 self.greaseMonkeyAct.setStatusTip(self.trUtf8(
 'Configure the GreaseMonkey Scripts'))
 self.greaseMonkeyAct.setWhatsThis(self.trUtf8(
 """<b>GreaseMonkey Scripts...</b>"""
-"""<p>Opens a dialog to configure the available GreaseMonkey Scripts.</p>"""
+"""<p>Opens a dialog to configure the available GreaseMonkey"""
+""" Scripts.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.greaseMonkeyAct.triggered[()].connect(
 self.__showGreaseMonkeyConfigDialog)
 self.__actions.append(self.greaseMonkeyAct)
-self.editMessageFilterAct = E5Action(self.trUtf8('Edit Message Filters'),
+self.editMessageFilterAct = E5Action(
-UI.PixmapCache.getIcon("warning.png"),
+self.trUtf8('Edit Message Filters'),
-self.trUtf8('Edit Message Filters...'), 0, 0, self,
+UI.PixmapCache.getIcon("warning.png"),
-'help_manage_message_filters')
+self.trUtf8('Edit Message Filters...'), 0, 0, self,
+'help_manage_message_filters')
 self.editMessageFilterAct.setStatusTip(self.trUtf8(
 'Edit the message filters used to suppress unwanted messages'))
 self.editMessageFilterAct.setWhatsThis(self.trUtf8(
 """<b>Edit Message Filters</b>"""
-"""<p>Opens a dialog to edit the message filters used to suppress"""
+"""<p>Opens a dialog to edit the message filters used to"""
-""" unwanted messages been shown in an error window.</p>"""
+""" suppress unwanted messages been shown in an error"""
+""" window.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.editMessageFilterAct.triggered[()].connect(
 E5ErrorMessage.editMessageFilters)
 self.__actions.append(self.editMessageFilterAct)
 if self.useQtHelp or self.initShortcutsOnly:
-self.syncTocAct = E5Action(self.trUtf8('Sync with Table of Contents'),
+self.syncTocAct = E5Action(
+self.trUtf8('Sync with Table of Contents'),
 UI.PixmapCache.getIcon("syncToc.png"),
 self.trUtf8('Sync with Table of Contents'),
 0, 0, self, 'help_sync_toc')
 self.syncTocAct.setStatusTip(self.trUtf8(
 'Synchronizes the table of contents with current page'))
 self.syncTocAct.setWhatsThis(self.trUtf8(
 """<b>Sync with Table of Contents</b>"""
-"""<p>Synchronizes the table of contents with current page.</p>"""
+"""<p>Synchronizes the table of contents with current"""
+""" page.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.syncTocAct.triggered[()].connect(self.__syncTOC)
 self.__actions.append(self.syncTocAct)
 self.showSearchAct.setWhatsThis(self.trUtf8(
 """<b>Search</b>"""
 """<p>Shows the search window.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.showSearchAct.triggered[()].connect(self.__showSearchWindow)
+self.showSearchAct.triggered[()].connect(
+self.__showSearchWindow)
 self.__actions.append(self.showSearchAct)
-self.manageQtHelpDocsAct = E5Action(self.trUtf8('Manage QtHelp Documents'),
+self.manageQtHelpDocsAct = E5Action(
+self.trUtf8('Manage QtHelp Documents'),
 self.trUtf8('Manage QtHelp &Documents'),
 0, 0, self, 'help_qthelp_documents')
 self.manageQtHelpDocsAct.setStatusTip(self.trUtf8(
 'Shows a dialog to manage the QtHelp documentation set'))
 self.manageQtHelpDocsAct.setWhatsThis(self.trUtf8(
 """<b>Manage QtHelp Documents</b>"""
-"""<p>Shows a dialog to manage the QtHelp documentation set.</p>"""
+"""<p>Shows a dialog to manage the QtHelp documentation"""
+""" set.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.manageQtHelpDocsAct.triggered[()].connect(
 self.__manageQtHelpDocumentation)
 self.__actions.append(self.manageQtHelpDocsAct)
-self.manageQtHelpFiltersAct = E5Action(self.trUtf8('Manage QtHelp Filters'),
+self.manageQtHelpFiltersAct = E5Action(
+self.trUtf8('Manage QtHelp Filters'),
 self.trUtf8('Manage QtHelp &Filters'),
 0, 0, self, 'help_qthelp_filters')
 self.manageQtHelpFiltersAct.setStatusTip(self.trUtf8(
 'Shows a dialog to manage the QtHelp filters'))
 self.manageQtHelpFiltersAct.setWhatsThis(self.trUtf8(
 if not self.initShortcutsOnly:
 self.manageQtHelpFiltersAct.triggered[()].connect(
 self.__manageQtHelpFilters)
 self.__actions.append(self.manageQtHelpFiltersAct)
-self.reindexDocumentationAct = E5Action(self.trUtf8('Reindex Documentation'),
+self.reindexDocumentationAct = E5Action(
+self.trUtf8('Reindex Documentation'),
 self.trUtf8('&Reindex Documentation'),
 0, 0, self, 'help_qthelp_reindex')
 self.reindexDocumentationAct.setStatusTip(self.trUtf8(
 'Reindexes the documentation set'))
 self.reindexDocumentationAct.setWhatsThis(self.trUtf8(
 self.clearPrivateDataAct = E5Action(self.trUtf8('Clear private data'),
 self.trUtf8('&Clear private data'),
 0, 0,
 self, 'help_clear_private_data')
-self.clearPrivateDataAct.setStatusTip(self.trUtf8('Clear private data'))
+self.clearPrivateDataAct.setStatusTip(self.trUtf8(
+'Clear private data'))
 self.clearPrivateDataAct.setWhatsThis(self.trUtf8(
 """<b>Clear private data</b>"""
-"""<p>Clears the private data like browsing history, search history"""
+"""<p>Clears the private data like browsing history, search"""
-""" or the favicons database.</p>"""
+""" history or the favicons database.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.clearPrivateDataAct.triggered[()].connect(self.__clearPrivateData)
+self.clearPrivateDataAct.triggered[()].connect(
+self.__clearPrivateData)
 self.__actions.append(self.clearPrivateDataAct)
 self.clearIconsAct = E5Action(self.trUtf8('Clear icons database'),
 self.trUtf8('Clear &icons database'),
 0, 0,
 self, 'help_clear_icons_db')
-self.clearIconsAct.setStatusTip(self.trUtf8('Clear the database of favicons'))
+self.clearIconsAct.setStatusTip(self.trUtf8(
+'Clear the database of favicons'))
 self.clearIconsAct.setWhatsThis(self.trUtf8(
 """<b>Clear icons database</b>"""
-"""<p>Clears the database of favicons of previously visited URLs.</p>"""
+"""<p>Clears the database of favicons of previously visited"""
+""" URLs.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.clearIconsAct.triggered[()].connect(self.__clearIconsDatabase)
 self.__actions.append(self.clearIconsAct)
-self.searchEnginesAct = E5Action(self.trUtf8('Configure Search Engines'),
+self.searchEnginesAct = E5Action(
-self.trUtf8('Configure Search &Engines...'),
+self.trUtf8('Configure Search Engines'),
-0, 0,
+self.trUtf8('Configure Search &Engines...'),
-self, 'help_search_engines')
+0, 0,
+self, 'help_search_engines')
 self.searchEnginesAct.setStatusTip(self.trUtf8(
 'Configure the available search engines'))
 self.searchEnginesAct.setWhatsThis(self.trUtf8(
 """<b>Configure Search Engines...</b>"""
-"""<p>Opens a dialog to configure the available search engines.</p>"""
+"""<p>Opens a dialog to configure the available search"""
+""" engines.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.searchEnginesAct.triggered[()].connect(
 self.__showEnginesConfigurationDialog)
 self.__actions.append(self.searchEnginesAct)
 UI.PixmapCache.getIcon("adBlockPlus.png"),
 self.trUtf8('&Ad Block...'),
 0, 0,
 self, 'help_adblock')
 self.adblockAct.setStatusTip(self.trUtf8(
 'Configure AdBlock subscriptions and rules'))
 self.adblockAct.setWhatsThis(self.trUtf8(
 """<b>Ad Block...</b>"""
-"""<p>Opens a dialog to configure AdBlock subscriptions and rules.</p>"""
+"""<p>Opens a dialog to configure AdBlock subscriptions and"""
+""" rules.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.adblockAct.triggered[()].connect(self.__showAdBlockDialog)
 self.__actions.append(self.adblockAct)
 UI.PixmapCache.getIcon("flashBlock.png"),
 self.trUtf8('&ClickToFlash...'),
 0, 0,
 self, 'help_flashblock')
 self.flashblockAct.setStatusTip(self.trUtf8(
 'Configure ClickToFlash whitelist'))
 self.flashblockAct.setWhatsThis(self.trUtf8(
 """<b>ClickToFlash...</b>"""
-"""<p>Opens a dialog to configure the ClickToFlash whitelist.</p>"""
+"""<p>Opens a dialog to configure the ClickToFlash"""
-))
+""" whitelist.</p>"""
-if not self.initShortcutsOnly:
+))
-self.flashblockAct.triggered[()].connect(self.__showClickToFlashDialog)
+if not self.initShortcutsOnly:
+self.flashblockAct.triggered[()].connect(
+self.__showClickToFlashDialog)
 self.__actions.append(self.flashblockAct)
 if SSL_AVAILABLE:
-self.certificatesAct = E5Action(self.trUtf8('Manage SSL Certificates'),
+self.certificatesAct = E5Action(
-UI.PixmapCache.getIcon("certificates.png"),
+self.trUtf8('Manage SSL Certificates'),
-self.trUtf8('Manage SSL Certificates...'),
+UI.PixmapCache.getIcon("certificates.png"),
-0, 0,
+self.trUtf8('Manage SSL Certificates...'),
-self, 'help_manage_certificates')
+0, 0,
+self, 'help_manage_certificates')
 self.certificatesAct.setStatusTip(self.trUtf8(
 'Manage the saved SSL certificates'))
 self.certificatesAct.setWhatsThis(self.trUtf8(
 """<b>Manage SSL Certificates...</b>"""
-"""<p>Opens a dialog to manage the saved SSL certificates.</p>"""
+"""<p>Opens a dialog to manage the saved SSL"""
+""" certificates.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.certificatesAct.triggered[()].connect(self.__showCertificatesDialog)
+self.certificatesAct.triggered[()].connect(
+self.__showCertificatesDialog)
 self.__actions.append(self.certificatesAct)
 self.toolsMonitorAct = E5Action(self.trUtf8('Network Monitor'),
 self.trUtf8('&Network Monitor...'),
 0, 0,
 self, 'help_tools_network_monitor')
-self.toolsMonitorAct.setStatusTip(self.trUtf8('Show the network monitor dialog'))
+self.toolsMonitorAct.setStatusTip(self.trUtf8(
+'Show the network monitor dialog'))
 self.toolsMonitorAct.setWhatsThis(self.trUtf8(
 """<b>Network Monitor...</b>"""
 """<p>Shows the network monitor dialog.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.toolsMonitorAct.triggered[()].connect(self.__showNetworkMonitor)
+self.toolsMonitorAct.triggered[()].connect(
+self.__showNetworkMonitor)
 self.__actions.append(self.toolsMonitorAct)
 self.showDownloadManagerAct = E5Action(self.trUtf8('Downloads'),
 self.trUtf8('Downloads'),
 0, 0, self, 'help_show_downloads')
 self.showDownloadManagerAct.setWhatsThis(self.trUtf8(
 """<b>Downloads</b>"""
 """<p>Shows the downloads window.</p>"""
 ))
 if not self.initShortcutsOnly:
-self.showDownloadManagerAct.triggered[()].connect(self.__showDownloadsWindow)
+self.showDownloadManagerAct.triggered[()].connect(
+self.__showDownloadsWindow)
 self.__actions.append(self.showDownloadManagerAct)
 self.feedsManagerAct = E5Action(self.trUtf8('RSS Feeds Dialog'),
 UI.PixmapCache.getIcon("rss22.png"),
 self.trUtf8('&RSS Feeds Dialog...'),
 QKeySequence(self.trUtf8("Ctrl+Shift+F", "Help|RSS Feeds Dialog")),
 0, self, 'help_rss_feeds')
 self.feedsManagerAct.setStatusTip(self.trUtf8(
 'Open a dialog showing the configured RSS feeds.'))
 self.feedsManagerAct.setWhatsThis(self.trUtf8(
 """<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>"""
+""" It can be used to mange the feeds and to show their"""
+""" contents.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.feedsManagerAct.triggered[()].connect(self.__showFeedsManager)
 self.__actions.append(self.feedsManagerAct)
 UI.PixmapCache.getIcon("helpAbout.png"),
 self.trUtf8('&Siteinfo Dialog...'),
 QKeySequence(self.trUtf8("Ctrl+Shift+I", "Help|Siteinfo Dialog")),
 0, self, 'help_siteinfo')
 self.siteInfoAct.setStatusTip(self.trUtf8(
 'Open a dialog showing some information about the current site.'))
 self.siteInfoAct.setWhatsThis(self.trUtf8(
 """<b>Siteinfo Dialog...</b>"""
 """<p>Opens a dialog showing some information about the current"""
 """ site.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.siteInfoAct.triggered[()].connect(self.__showSiteinfoDialog)
 self.__actions.append(self.siteInfoAct)
-self.userAgentManagerAct = E5Action(self.trUtf8('Manage User Agent Settings'),
+self.userAgentManagerAct = E5Action(
+self.trUtf8('Manage User Agent Settings'),
 self.trUtf8('Manage &User Agent Settings'),
 0, 0, self, 'help_user_agent_settings')
 self.userAgentManagerAct.setStatusTip(self.trUtf8(
 'Shows a dialog to manage the User Agent settings'))
 self.userAgentManagerAct.setWhatsThis(self.trUtf8(
 self.synchronizationAct = E5Action(self.trUtf8('Synchronize data'),
 UI.PixmapCache.getIcon("sync.png"),
 self.trUtf8('&Synchronize Data...'),
 0, 0, self, 'help_synchronize_data')
 self.synchronizationAct.setStatusTip(self.trUtf8(
 'Shows a dialog to synchronize data via the network'))
 self.synchronizationAct.setWhatsThis(self.trUtf8(
 """<b>Synchronize Data...</b>"""
-"""<p>This shows a dialog to synchronize data via the network.</p>"""
+"""<p>This shows a dialog to synchronize data via the"""
+""" network.</p>"""
 ))
 if not self.initShortcutsOnly:
 self.synchronizationAct.triggered[()].connect(
 self.__showSyncDialog)
 self.__actions.append(self.synchronizationAct)
 menu.addAction(self.zoomTextOnlyAct)
 menu.addSeparator()
 menu.addAction(self.pageSourceAct)
 menu.addAction(self.fullScreenAct)
 if hasattr(QWebSettings, 'defaultTextEncoding'):
-self.__textEncodingMenu = menu.addMenu(self.trUtf8("Text Encoding"))
+self.__textEncodingMenu = menu.addMenu(
+self.trUtf8("Text Encoding"))
 self.__textEncodingMenu.aboutToShow.connect(
 self.__aboutToShowTextEncodingMenu)
 self.__textEncodingMenu.triggered.connect(self.__setTextEncoding)
 menu = mb.addMenu(self.trUtf8('&Go'))
 self.filterCombo.setMinimumWidth(
 QFontMetrics(QFont()).width("ComboBoxWithEnoughWidth"))
 filtertb.addWidget(QLabel(self.trUtf8("Filtered by: ")))
 filtertb.addWidget(self.filterCombo)
 self.__helpEngine.setupFinished.connect(self.__setupFilterCombo)
-self.filterCombo.activated[str].connect(self.__filterQtHelpDocumentation)
+self.filterCombo.activated[str].connect(
+self.__filterQtHelpDocumentation)
 self.__setupFilterCombo()
 settingstb = self.addToolBar(self.trUtf8("Settings"))
 settingstb.setObjectName("SettingsToolBar")
 settingstb.setIconSize(UI.Config.ToolBarIconSize)
 backButton.setMenu(self.backMenu)
 backButton.setPopupMode(QToolButton.MenuButtonPopup)
 self.forwardMenu = QMenu(self)
 self.forwardMenu.aboutToShow.connect(self.__showForwardMenu)
-self.forwardMenu.triggered.connect(self.__navigationMenuActionTriggered)
+self.forwardMenu.triggered.connect(
+self.__navigationMenuActionTriggered)
 forwardButton = gotb.widgetForAction(self.forwardAct)
 forwardButton.setMenu(self.forwardMenu)
 forwardButton.setPopupMode(QToolButton.MenuButtonPopup)
 from .Bookmarks.BookmarksToolBar import BookmarksToolBar
 vttb.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
 self.virustotalSearchEdit = QLineEdit()
 self.virustotalSearchEdit.setMaximumWidth(250)
 self.virustotalSearchEdit.setWhatsThis(self.trUtf8(
 """<h2>File search</h2>"""
-"""<p>In order to search for the last VirusTotal report on a given file"""
+"""<p>In order to search for the last VirusTotal report on a"""
-""" just enter its hash. Currently the allowed hashes are MD5, SHA1 and"""
+""" given file just enter its hash. Currently the allowed"""
-""" SHA256. You can also search for a particular file report by typing"""
+""" hashes are MD5, SHA1 and SHA256. You can also search for"""
-""" in its permalink id.</p>"""
+""" a particular file report by typing in its permalink id.</p>"""
 """<h2>URL search</h2>"""
-"""<p>URL searches are simple, just type in the given URL, the application"""
+"""<p>URL searches are simple, just type in the given URL, the"""
-""" will normalize it and compare it with the entries in VirusTotal's"""
+""" application will normalize it and compare it with the"""
-""" database. Alternatively you may enter the MD5 hash of an URL preceded"""
+""" entries in VirusTotal's database. Alternatively you may"""
-""" by "url:", e.g. url:7f911bbcf618f052ac6b9928600d2820.</p>"""
+""" enter the MD5 hash of an URL preceded by "url:", e.g."""
+""" url:7f911bbcf618f052ac6b9928600d2820.</p>"""
 """<h2>User search</h2>"""
-"""<p>Do you want to know whether a friend has a VT Community account?"""
+"""<p>Do you want to know whether a friend has a VT Community"""
-""" Simply type in his nick preceded by the symbol "@", e.g."""
+""" account? Simply type in his nick preceded by the symbol"""
-""" @EmilianoMartinez.</p>"""
+""" "@", e.g. @EmilianoMartinez.</p>"""
 """<h2>Search through comments</h2>"""
-"""<p>The comments in VT Community may often help in disinfecting your PC"""
+"""<p>The comments in VT Community may often help in"""
-""" or may proof themselves useful when analysing a particular malware"""
+""" disinfecting your PC or may proof themselves useful when"""
-""" sample, comment tags enable users to search through the VT Community"""
+""" analysing a particular malware sample, comment tags enable"""
-""" reviews. The standard file tags are: {0} The standard URL tags are: {1}"""
+""" users to search through the VT Community reviews. The"""
+""" standard file tags are: {0} The standard URL tags are: {1}"""
 """User generated tags are preceded by the symbol "#", e.g."""
 """ #disinfect.</p>"""
 ).format(
 """<ul>"""
 """<li>goodware</li>"""
 """<li>phishingsite</li>"""
 """<li>browserexploit</li>"""
 """<li>spamlink</li>"""
 """</ul>""",
 ))
-self.virustotalSearchEdit.textChanged.connect(self.__virusTotalSearchChanged)
+self.virustotalSearchEdit.textChanged.connect(
-self.virustotalSearchEdit.returnPressed.connect(self.__virusTotalSearch)
+self.__virusTotalSearchChanged)
+self.virustotalSearchEdit.returnPressed.connect(
+self.__virusTotalSearch)
 vttb.addWidget(self.virustotalSearchEdit)
 self.virustotalSearchAct = vttb.addAction(
 UI.PixmapCache.getIcon("virustotal.png"),
 self.trUtf8("Search VirusTotal"),
 self.__virusTotalSearch)
 if fwidget:
 fwidget.prevTab()
 def __switchTab(self):
 """
-Private slot used to switch between the current and the previous current tab.
+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:
 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.
+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.trUtf8("eric5 Web Browser"), self.trUtf8(
 """<b>eric5 Web Browser - {0}</b>"""
-"""<p>The eric5 Web Browser is a combined help file and HTML browser."""
+"""<p>The eric5 Web Browser is a combined help file and HTML"""
-""" It is part of the eric5 development toolset.</p>"""
+""" browser. It is part of the eric5 development toolset.</p>"""
 ).format(Version))
 def __aboutQt(self):
 """
 Private slot to show info about Qt.
 def setForwardAvailable(self, b):
 """
 Public slot called when forward references are available.
-@param b flag indicating the availability of the forwards action (boolean)
+@param b flag indicating the availability of the forwards action
+(boolean)
 """
 self.forwardAct.setEnabled(b)
 def setLoadingActions(self, b):
 """
 state = self.saveState()
 Preferences.setHelp("HelpViewerState", state)
 if Preferences.getHelp("SaveGeometry"):
 if not self.__isFullScreen():
-Preferences.setGeometry("HelpViewerGeometry", self.saveGeometry())
+Preferences.setGeometry("HelpViewerGeometry",
+self.saveGeometry())
 else:
 Preferences.setGeometry("HelpViewerGeometry", QByteArray())
 try:
 if self.fromEric or len(self.__class__.helpwindows) > 1:
-del self.__class__.helpwindows[self.__class__.helpwindows.index(self)]
+del self.__class__.helpwindows[
+self.__class__.helpwindows.index(self)]
 except ValueError:
 pass
 if not self.fromEric:
 Preferences.syncPreferences()
 """
 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)
+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.setIcon(
+UI.PixmapCache.getIcon("windowFullscreen.png"))
 self.fullScreenAct.setIconText(self.trUtf8('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.setIcon(
+UI.PixmapCache.getIcon("windowRestore.png"))
 self.fullScreenAct.setIconText(self.trUtf8('Restore Window'))
 def __isFullScreen(self):
 """
 Private method to determine, if the window is in full screen mode.
 Private slot to switch private browsing.
 """
 settings = QWebSettings.globalSettings()
 pb = settings.testAttribute(QWebSettings.PrivateBrowsingEnabled)
 if not pb:
-txt = self.trUtf8("""<b>Are you sure you want to turn on private"""
+txt = self.trUtf8(
-""" browsing?</b><p>When private browsing is turned on,"""
+"""<b>Are you sure you want to turn on private"""
-""" web pages are not added to the history, searches"""
+""" browsing?</b><p>When private browsing is turned on,"""
-""" are not added to the list of recent searches and"""
+""" web pages are not added to the history, searches"""
-""" web site icons and cookies are not stored."""
+""" are not added to the list of recent searches and"""
-""" HTML5 offline storage will be deactivated."""
+""" web site icons and cookies are not stored."""
-""" Until you close the window, you can still click"""
+""" HTML5 offline storage will be deactivated."""
-""" the Back and Forward buttons to return to the"""
+""" Until you close the window, you can still click"""
-""" web pages you have opened.</p>""")
+""" 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)
 """
 return self.tabWidget.currentBrowser()
 def browserAt(self, index):
 """
-Public method to get a reference to the help browser with the given 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 __showPreferences(self):
 """
 Private slot to set the preferences.
 """
 from Preferences.ConfigurationDialog import ConfigurationDialog
-dlg = ConfigurationDialog(self, 'Configuration', True,
+dlg = ConfigurationDialog(
-fromEric=self.fromEric,
+self, 'Configuration', True, fromEric=self.fromEric,
 displayMode=ConfigurationDialog.HelpBrowserMode)
 dlg.preferencesChanged.connect(self.preferencesChanged)
 dlg.masterPasswordChanged.connect(self.masterPasswordChanged)
 dlg.show()
 if self.__lastConfigurationPageName:
 dlg.showConfigurationPageByName(self.__lastConfigurationPageName)
 def preferencesChanged(self):
 """
 Public slot to handle a change of preferences.
 """
 if not self.fromEric:
-self.setStyle(Preferences.getUI("Style"), Preferences.getUI("StyleSheet"))
+self.setStyle(Preferences.getUI("Style"),
+Preferences.getUI("StyleSheet"))
 self.__initWebSettings()
 self.networkAccessManager().preferencesChanged()
 def __showCookiesConfiguration(self):
 """
 Private slot to configure the cookies handling.
 """
-from .CookieJar.CookiesConfigurationDialog import CookiesConfigurationDialog
+from .CookieJar.CookiesConfigurationDialog import \
+CookiesConfigurationDialog
 dlg = CookiesConfigurationDialog(self)
 dlg.exec_()
 def __showOfflineStorageConfiguration(self):
 """
 Private slot to configure the offline storage.
 """
-from .OfflineStorage.OfflineStorageConfigDialog import OfflineStorageConfigDialog
+from .OfflineStorage.OfflineStorageConfigDialog import \
+OfflineStorageConfigDialog
 dlg = OfflineStorageConfigDialog(self)
 if dlg.exec_() == QDialog.Accepted:
 dlg.storeData()
 self.__initWebSettings()
 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)
+sizePolicy = QSizePolicy(QSizePolicy.Preferred,
+QSizePolicy.Maximum)
 label = QLabel(self.trUtf8("Updating search index"))
 label.setSizePolicy(sizePolicy)
 layout.addWidget(label)
 progressBar.setTextVisible(False)
 progressBar.setFixedHeight(16)
 progressBar.setSizePolicy(sizePolicy)
 layout.addWidget(progressBar)
-self.statusBar().insertPermanentWidget(0, self.__indexingProgress)
+self.statusBar().insertPermanentWidget(
+0, self.__indexingProgress)
 def __indexingFinished(self):
 """
 Private slot to handle the start of the indexing process.
 """
 def __searchForWord(self):
 """
 Private slot to search for a word.
 """
-if self.useQtHelp and not self.__indexing and self.__searchWord is not None:
+if self.useQtHelp and not self.__indexing and \
+self.__searchWord is not None:
 self.__searchDock.show()
 self.__searchDock.raise_()
-query = QHelpSearchQuery(QHelpSearchQuery.DEFAULT, [self.__searchWord])
+query = QHelpSearchQuery(QHelpSearchQuery.DEFAULT,
+[self.__searchWord])
 self.__searchEngine.search([query])
 self.__searchWord = None
 def search(self, word):
 """
 Private slot to look for new documentation to be loaded into the
 help database.
 """
 if self.useQtHelp:
 from .HelpDocsInstaller import HelpDocsInstaller
-self.__helpInstaller = HelpDocsInstaller(self.__helpEngine.collectionFile())
+self.__helpInstaller = HelpDocsInstaller(
-self.__helpInstaller.errorMessage.connect(self.__showInstallationError)
+self.__helpEngine.collectionFile())
+self.__helpInstaller.errorMessage.connect(
+self.__showInstallationError)
 self.__helpInstaller.docsInstalled.connect(self.__docsInstalled)
-self.statusBar().showMessage(self.trUtf8("Looking for Documentation..."))
+self.statusBar().showMessage(
+self.trUtf8("Looking for Documentation..."))
 self.__helpInstaller.installDocs()
 def __showInstallationError(self, message):
 """
 Private slot to show installation errors.
 def __docsInstalled(self, installed):
 """
 Private slot handling the end of documentation installation.
-@param installed flag indicating that documents were installed (boolean)
+@param installed flag indicating that documents were installed
+(boolean)
 """
 if self.useQtHelp:
 if installed:
 self.__helpEngine.setupData()
 self.statusBar().clearMessage()
 def __aboutToShowSettingsMenu(self):
 """
 Private slot to show the Settings menu.
 """
-self.editMessageFilterAct.setEnabled(E5ErrorMessage.messageHandlerInstalled())
+self.editMessageFilterAct.setEnabled(
+E5ErrorMessage.messageHandlerInstalled())
 def __showBackMenu(self):
 """
 Private slot showing the backwards navigation menu.
 """
 def __navigationMenuActionTriggered(self, act):
 """
 Private slot to go to the selected page.
-@param act reference to the action selected in the navigation menu (QAction)
+@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:
 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/"
+self.newTab(
-"{0}/flashplayer/help/settings_manager07.html".format(
+"http://www.macromedia.com/support/documentation/"
-langCode))
+"{0}/flashplayer/help/settings_manager07.html".format(
+langCode))
 def __showEnginesConfigurationDialog(self):
 """
 Private slot to show the search engines configuration dialog.
 """
 dlg = OpenSearchDialog(self)
 dlg.exec_()
 def searchEnginesAction(self):
 """
-Public method to get a reference to the search engines configuration action.
+Public method to get a reference to the search engines configuration
+action.
 @return reference to the search engines configuration action (QAction)
 """
 return self.searchEnginesAct
 hostUrl.setScheme(url.scheme())
 hostUrl.setHost(url.host())
 icon = HelpWindow.__getWebIcon(hostUrl)
 if icon.isNull():
-pixmap = QWebSettings.webGraphic(QWebSettings.DefaultFrameIconGraphic)
+pixmap = QWebSettings.webGraphic(
+QWebSettings.DefaultFrameIconGraphic)
 if pixmap.isNull():
 pixmap = UI.PixmapCache.getPixmap("defaultIcon.png")
-QWebSettings.setWebGraphic(QWebSettings.DefaultFrameIconGraphic, pixmap)
+QWebSettings.setWebGraphic(
+QWebSettings.DefaultFrameIconGraphic, pixmap)
 return QIcon(pixmap)
 return icon
 @staticmethod
 @classmethod
 def personalInformationManager(cls):
 """
 Class method to get a reference to the personal information manager.
-@return reference to the personal information manager (PersonalInformationManager)
+@return reference to the personal information manager
+(PersonalInformationManager)
 """
 if cls._personalInformationManager is None:
-from .PersonalInformationManager.PersonalInformationManager import \
+from .PersonalInformationManager.PersonalInformationManager \
-PersonalInformationManager
+import PersonalInformationManager
 cls._personalInformationManager = PersonalInformationManager()
 return cls._personalInformationManager
 @classmethod
 codecs = []
 for codec in QTextCodec.availableCodecs():
 codecs.append(str(codec, encoding="utf-8").lower())
 codecs.sort()
-defaultTextEncoding = QWebSettings.globalSettings().defaultTextEncoding().lower()
+defaultTextEncoding = \
+QWebSettings.globalSettings().defaultTextEncoding().lower()
 if defaultTextEncoding in codecs:
 currentCodec = defaultTextEncoding
 else:
 currentCodec = ""
 act.setCheckable(True)
 if currentCodec == codec:
 act.setChecked(True)
 isDefaultEncodingUsed = False
-act = self.__textEncodingMenu.addAction(self.trUtf8("Default Encoding"))
+act = self.__textEncodingMenu.addAction(
+self.trUtf8("Default Encoding"))
 act.setData("")
 act.setCheckable(True)
 act.setChecked(isDefaultEncodingUsed)
 self.__textEncodingMenu.addMenu(uniMenu)
 self.__textEncodingMenu.addMenu(isoMenu)
 requestData = VirusTotalAPI.getSearchRequestData(search)
 self.newTab(requestData=requestData)
 def __virusTotalScanCurrentSite(self):
 """
-Private slot to ask VirusTotal for a scan of the URL of the current browser.
+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"]:
 userStyle += fileData
 except IOError:
 pass
 encodedStyle = bytes(QByteArray(userStyle).toBase64()).decode()
-dataString = "data:text/css;charset=utf-8;base64,{0}".format(encodedStyle)
+dataString = "data:text/css;charset=utf-8;base64,{0}".format(
+encodedStyle)
 return QUrl(dataString)
 ##########################################
 ## Support for desktop notifications below
 @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 cls._fromEric:
-e5App().getObject("UserInterface").showNotification(icon, heading, text)
+e5App().getObject("UserInterface").showNotification(
+icon, heading, text)
 else:
 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.setTimeout(
-cls._notification.move(Preferences.getUI("NotificationPosition"))
+Preferences.getUI("NotificationTimeout"))
+cls._notification.move(
+Preferences.getUI("NotificationPosition"))
 cls._notification.show()
 @classmethod
 def notificationsEnabled(cls):
 """

Mercurial Repositories > eric / file comparison

comparison: Helpviewer/HelpWindow.py

Helpviewer/HelpWindow.py