eric: WebBrowser/WebBrowserWindow.py@fb24ccb25ff5 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2016 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the web browser main window.
 """
 from __future__ import unicode_literals
 try:
     str = unicode           # __IGNORE_EXCEPTION__
 except NameError:
     pass
 import os
 import shutil
 import sys
 from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QSize, QTimer, \
     QUrl, QTextCodec, QProcess, QEvent
 from PyQt5.QtGui import QDesktopServices, QKeySequence, QFont, QFontMetrics
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QSizePolicy, QDockWidget, \
     QComboBox, QLabel, QSplitter, QMenu, QToolButton, QLineEdit, \
     QApplication, QWhatsThis, QDialog, QHBoxLayout, QProgressBar, QAction, \
     QInputDialog
 from PyQt5.QtWebEngineWidgets import QWebEngineSettings, QWebEnginePage, \
     QWebEngineProfile, QWebEngineScript
 try:
     from PyQt5.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
     QTHELP_AVAILABLE = True
 except ImportError:
     QTHELP_AVAILABLE = False
 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 .data import icons_rc          # __IGNORE_WARNING__
 from .data import html_rc           # __IGNORE_WARNING__
 from .data import javascript_rc     # __IGNORE_WARNING__
 from .Tools import Scripts, WebBrowserTools, WebIconProvider
 from .ZoomManager import ZoomManager
 from eric6config import getConfig
 class WebBrowserWindow(E5MainWindow):
     """
     Class implementing the web browser main window.
     @signal webBrowserClosed() emitted after the window was requested to close
     @signal zoomTextOnlyChanged(bool) emitted after the zoom text only setting
         was changed
     """
     webBrowserClosed = pyqtSignal()
     BrowserWindows = []
     _fromEric = False
     UseQtHelp = QTHELP_AVAILABLE
     _isPrivate = False
     _webProfile = None
     _networkManager = 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
     _imageSearchEngine = None
     _autoScroller = None
     def __init__(self, home, path, parent, name, fromEric=False,
                  initShortcutsOnly=False, searchWord=None,
                  private=False, qthelp=False, settingsDir=""):
         """
         Constructor
         @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
             eric6 (boolean)
         @keyparam initShortcutsOnly flag indicating to just initialize the
             keyboard shortcuts (boolean)
         @keyparam searchWord word to search for (string)
         @keyparam private flag indicating a private browsing window (bool)
         @keyparam qthelp flag indicating to enable the QtHelp support (bool)
         @keyparam settingsDir directory to be used for the settings files (str)
         """
         super(WebBrowserWindow, self).__init__(parent)
         self.setObjectName(name)
         self.setWindowTitle(self.tr("eric6 Web Browser"))
         self.__settingsDir = settingsDir
         self.__fromEric = fromEric
         WebBrowserWindow._fromEric = fromEric
         self.__initShortcutsOnly = initShortcutsOnly
         self.setWindowIcon(UI.PixmapCache.getIcon("ericWeb.png"))
         self.__mHistory = []
         self.__lastConfigurationPageName = ""
         WebBrowserWindow._isPrivate = private
         self.__eventMouseButtons = Qt.NoButton
         self.__eventKeyboardModifiers = Qt.NoModifier
         if self.__initShortcutsOnly:
             WebBrowserWindow.setUseQtHelp(
                 self.__fromEric or qthelp or bool(searchWord))
             self.__initActions()
         else:
             if Preferences.getWebBrowser("WebInspectorEnabled"):
                 os.putenv(
                     "QTWEBENGINE_REMOTE_DEBUGGING",
                     str(Preferences.getWebBrowser("WebInspectorPort")))
             WebBrowserWindow.setUseQtHelp(
                 self.__fromEric or qthelp or bool(searchWord))
             self.webProfile(private)
             self.networkManager()
             self.__htmlFullScreen = False
             self.__windowStates = 0
             from .SearchWidget import SearchWidget
             from .QtHelp.HelpTocWidget import HelpTocWidget
             from .QtHelp.HelpIndexWidget import HelpIndexWidget
             from .QtHelp.HelpSearchWidget import HelpSearchWidget
             from .WebBrowserView import WebBrowserView
             from .WebBrowserTabWidget import WebBrowserTabWidget
             from .AdBlock.AdBlockIcon import AdBlockIcon
             from .VirusTotal.VirusTotalApi import VirusTotalAPI
             if not self.__fromEric:
                 self.setStyle(Preferences.getUI("Style"),
                               Preferences.getUI("StyleSheet"))
                 # initialize some SSL stuff
                 from E5Network.E5SslUtilities import initSSL
                 initSSL()
             if WebBrowserWindow.useQtHelp:
                 self.__helpEngine = QHelpEngine(
                     os.path.join(Utilities.getConfigDir(),
                                  "web_browser", "eric6help.qhc"),
                     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(
                 WebBrowserView.ZoomLevels, WebBrowserView.ZoomLevelDefault)
             self.__zoomWidget.valueChanged.connect(self.__zoomValueChanged)
             self.__tabWidget = WebBrowserTabWidget(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.__searchWidget = SearchWidget(self, self)
             centralWidget = QWidget()
             layout = QVBoxLayout()
             layout.setContentsMargins(1, 1, 1, 1)
             layout.addWidget(self.__tabWidget)
             layout.addWidget(self.__searchWidget)
             self.__tabWidget.setSizePolicy(
                 QSizePolicy.Preferred, QSizePolicy.Expanding)
             centralWidget.setLayout(layout)
             self.setCentralWidget(centralWidget)
             self.__searchWidget.hide()
             if WebBrowserWindow.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)
             # JavaScript Console window
             from .WebBrowserJavaScriptConsole import \
                 WebBrowserJavaScriptConsole
             self.__javascriptConsole = WebBrowserJavaScriptConsole(self)
             self.__javascriptConsoleDock = QDockWidget(
                 self.tr("JavaScript Console"))
             self.__javascriptConsoleDock.setObjectName("JavascriptConsole")
             self.__javascriptConsoleDock.setAllowedAreas(
                 Qt.BottomDockWidgetArea | Qt.TopDockWidgetArea)
             self.__javascriptConsoleDock.setWidget(self.__javascriptConsole)
             self.addDockWidget(Qt.BottomDockWidgetArea,
                                self.__javascriptConsoleDock)
             if Preferences.getWebBrowser("SaveGeometry"):
                 g = Preferences.getGeometry("WebBrowserGeometry")
             else:
                 g = QByteArray()
             if g.isEmpty():
                 s = QSize(800, 800)
                 self.resize(s)
             else:
                 self.restoreGeometry(g)
             WebBrowserWindow.BrowserWindows.append(self)
             self.__setIconDatabasePath()
             self.__initWebEngineSettings()
             # initialize some of our class objects
             self.passwordManager()
             self.historyManager()
             self.greaseMonkeyManager()
             self.__initActions()
             self.__initMenus()
             self.__initToolbars()
             syncMgr = self.syncManager()
             syncMgr.syncMessage.connect(self.statusBar().showMessage)
             syncMgr.syncError.connect(self.statusBar().showMessage)
             self.__tabWidget.newBrowser(home)
             self.__tabWidget.currentBrowser().setFocus()
             self.__adBlockIcon = AdBlockIcon(self)
             self.statusBar().addPermanentWidget(self.__adBlockIcon)
             self.__adBlockIcon.setEnabled(
                 Preferences.getWebBrowser("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)
             QDesktopServices.setUrlHandler("http", self.__linkActivated)
             QDesktopServices.setUrlHandler("https", self.__linkActivated)
             # setup connections
             self.__activating = False
             if WebBrowserWindow.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.getWebBrowser("WebBrowserState")
             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 WebBrowserWindow.useQtHelp:
                 QTimer.singleShot(0, self.__lookForNewDocumentation)
                 if self.__searchWord is not None:
                     QTimer.singleShot(0, self.__searchForWord)
             self.__lastActiveWindow = None
             e5App().focusChanged[QWidget, QWidget].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 fromEric(self):
         """
         Public method to check, if the web browser was called from within the
         eric IDE.
         @return flag indicating that the browserw as opened from within eric
         @rtype bool
         """
         return self.__fromEric
     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(),
                                             "web_browser", "favicons")
             if not os.path.exists(iconDatabasePath):
                 os.makedirs(iconDatabasePath)
         else:
             iconDatabasePath = ""   # setting an empty path disables it
         WebIconProvider.instance().setIconDatabasePath(iconDatabasePath)
     def __initWebEngineSettings(self):
         """
         Private method to set the global web settings.
         """
         settings = QWebEngineSettings.globalSettings()
         settings.setFontFamily(
             QWebEngineSettings.StandardFont,
             Preferences.getWebBrowser("StandardFontFamily"))
         settings.setFontFamily(
             QWebEngineSettings.FixedFont,
             Preferences.getWebBrowser("FixedFontFamily"))
         settings.setFontFamily(
             QWebEngineSettings.SerifFont,
             Preferences.getWebBrowser("SerifFontFamily"))
         settings.setFontFamily(
             QWebEngineSettings.SansSerifFont,
             Preferences.getWebBrowser("SansSerifFontFamily"))
         settings.setFontFamily(
             QWebEngineSettings.CursiveFont,
             Preferences.getWebBrowser("CursiveFontFamily"))
         settings.setFontFamily(
             QWebEngineSettings.FantasyFont,
             Preferences.getWebBrowser("FantasyFontFamily"))
         settings.setFontSize(
             QWebEngineSettings.DefaultFontSize,
             Preferences.getWebBrowser("DefaultFontSize"))
         settings.setFontSize(
             QWebEngineSettings.DefaultFixedFontSize,
             Preferences.getWebBrowser("DefaultFixedFontSize"))
         settings.setFontSize(
             QWebEngineSettings.MinimumFontSize,
             Preferences.getWebBrowser("MinimumFontSize"))
         settings.setFontSize(
             QWebEngineSettings.MinimumLogicalFontSize,
             Preferences.getWebBrowser("MinimumLogicalFontSize"))
         styleSheet = Preferences.getWebBrowser("UserStyleSheet")
         self.__setUserStyleSheet(styleSheet)
         settings.setAttribute(
             QWebEngineSettings.AutoLoadImages,
             Preferences.getWebBrowser("AutoLoadImages"))
         settings.setAttribute(
             QWebEngineSettings.JavascriptEnabled,
             Preferences.getWebBrowser("JavaScriptEnabled"))
         settings.setAttribute(
             QWebEngineSettings.JavascriptCanOpenWindows,
             Preferences.getWebBrowser("JavaScriptCanOpenWindows"))
         settings.setAttribute(
             QWebEngineSettings.JavascriptCanAccessClipboard,
             Preferences.getWebBrowser("JavaScriptCanAccessClipboard"))
         settings.setAttribute(
             QWebEngineSettings.PluginsEnabled,
             Preferences.getWebBrowser("PluginsEnabled"))
         if self.isPrivate():
             settings.setAttribute(
                 QWebEngineSettings.LocalStorageEnabled, False)
         else:
             settings.setAttribute(
                 QWebEngineSettings.LocalStorageEnabled,
                 Preferences.getWebBrowser("LocalStorageEnabled"))
         settings.setDefaultTextEncoding(
             Preferences.getWebBrowser("DefaultTextEncoding"))
         settings.setAttribute(
             QWebEngineSettings.SpatialNavigationEnabled,
             Preferences.getWebBrowser("SpatialNavigationEnabled"))
         settings.setAttribute(
             QWebEngineSettings.LinksIncludedInFocusChain,
             Preferences.getWebBrowser("LinksIncludedInFocusChain"))
         settings.setAttribute(
             QWebEngineSettings.LocalContentCanAccessRemoteUrls,
             Preferences.getWebBrowser("LocalContentCanAccessRemoteUrls"))
         settings.setAttribute(
             QWebEngineSettings.LocalContentCanAccessFileUrls,
             Preferences.getWebBrowser("LocalContentCanAccessFileUrls"))
         settings.setAttribute(
             QWebEngineSettings.XSSAuditingEnabled,
             Preferences.getWebBrowser("XSSAuditingEnabled"))
         settings.setAttribute(
             QWebEngineSettings.ScrollAnimatorEnabled,
             Preferences.getWebBrowser("ScrollAnimatorEnabled"))
         settings.setAttribute(
             QWebEngineSettings.ErrorPageEnabled,
             Preferences.getWebBrowser("ErrorPageEnabled"))
         settings.setAttribute(
             QWebEngineSettings.FullScreenSupportEnabled,
             Preferences.getWebBrowser("FullScreenSupportEnabled"))
     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")),
 , self, 'webbrowser_file_new_tab')
         self.newTabAct.setStatusTip(self.tr('Open a new web browser tab'))
         self.newTabAct.setWhatsThis(self.tr(
             """<b>New Tab</b>"""
             """<p>This opens a new web browser tab.</p>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_file_new_window')
         self.newAct.setStatusTip(self.tr('Open a new web browser window'))
         self.newAct.setWhatsThis(self.tr(
             """<b>New Window</b>"""
             """<p>This opens a new web browser window in the current"""
             """ privacy mode.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.newAct.triggered.connect(self.newWindow)
         self.__actions.append(self.newAct)
         self.newPrivateAct = E5Action(
             self.tr('New Private Window'),
             UI.PixmapCache.getIcon("privateMode.png"),
             self.tr('New &Private Window'),
             QKeySequence(self.tr("Ctrl+Shift+P", "File|New Private Window")),
 , self, 'webbrowser_file_new_private_window')
         self.newPrivateAct.setStatusTip(self.tr(
             'Open a new private web browser window'))
         self.newPrivateAct.setWhatsThis(self.tr(
             """<b>New Private Window</b>"""
             """<p>This opens a new private web browser window by starting"""
             """ a new web browser instance in private mode.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.newPrivateAct.triggered.connect(self.newPrivateWindow)
         self.__actions.append(self.newPrivateAct)
         self.openAct = E5Action(
             self.tr('Open File'),
             UI.PixmapCache.getIcon("open.png"),
             self.tr('&Open File'),
             QKeySequence(self.tr("Ctrl+O", "File|Open")),
 , self, 'webbrowser_file_open')
         self.openAct.setStatusTip(self.tr('Open a file for display'))
         self.openAct.setWhatsThis(self.tr(
             """<b>Open File</b>"""
             """<p>This opens a new file for display."""
             """ It pops up a file selection dialog.</p>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_file_open_tab')
         self.openTabAct.setStatusTip(
             self.tr('Open a file for display in a new tab'))
         self.openTabAct.setWhatsThis(self.tr(
             """<b>Open File in New Tab</b>"""
             """<p>This opens a new file for display in a new tab."""
             """ It pops up a file selection dialog.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.openTabAct.triggered.connect(self.__openFileNewTab)
         self.__actions.append(self.openTabAct)
         # TODO: Qt 5.7: Save
 ##
 ##        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, 'webbrowser_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>"""
 ##        ))
 ##        if not self.__initShortcutsOnly:
 ##            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, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             self.importBookmarksAct.triggered.connect(
                 bookmarksManager.importBookmarks)
         self.__actions.append(self.importBookmarksAct)
         self.exportBookmarksAct = E5Action(
             self.tr('Export Bookmarks'),
             self.tr('&Export Bookmarks...'),
 , 0, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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, self, 'webbrowser_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>"""
             ))
             if not self.__initShortcutsOnly:
                 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, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_file_close')
         self.closeAct.setStatusTip(self.tr(
             'Close the current help window'))
         self.closeAct.setWhatsThis(self.tr(
             """<b>Close</b>"""
             """<p>Closes the current web browser window.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.closeAct.triggered.connect(self.__tabWidget.closeBrowser)
         self.__actions.append(self.closeAct)
         self.closeAllAct = E5Action(
             self.tr('Close All'),
             self.tr('Close &All'),
 , 0, self, 'webbrowser_file_close_all')
         self.closeAllAct.setStatusTip(self.tr('Close all help windows'))
         self.closeAllAct.setWhatsThis(self.tr(
             """<b>Close All</b>"""
             """<p>Closes all web browser windows except the first one.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.closeAllAct.triggered.connect(
                 self.__tabWidget.closeAllBrowsers)
         self.__actions.append(self.closeAllAct)
         self.exitAct = E5Action(
             self.tr('Quit'),
             UI.PixmapCache.getIcon("exit.png"),
             self.tr('&Quit'),
             QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             if self.__fromEric:
                 self.exitAct.triggered.connect(self.close)
             else:
                 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")),
 , self, 'webbrowser_go_backward')
         self.backAct.setStatusTip(self.tr('Move one screen backward'))
         self.backAct.setWhatsThis(self.tr(
             """<b>Backward</b>"""
             """<p>Moves one screen backward. If none is"""
             """ available, this action is disabled.</p>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_go_foreward')
         self.forwardAct.setStatusTip(self.tr(
             'Move one screen forward'))
         self.forwardAct.setWhatsThis(self.tr(
             """<b>Forward</b>"""
             """<p>Moves one 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.tr('Home'),
             UI.PixmapCache.getIcon("home.png"),
             self.tr('&Home'),
             QKeySequence(self.tr("Ctrl+Home", "Go|Home")),
 , self, 'webbrowser_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 screen.</p>"""
         ))
         if not self.__initShortcutsOnly:
             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, 'webbrowser_go_reload')
         self.reloadAct.setStatusTip(self.tr(
             'Reload the current screen'))
         self.reloadAct.setWhatsThis(self.tr(
             """<b>Reload</b>"""
             """<p>Reloads the current screen.</p>"""
         ))
         if not self.__initShortcutsOnly:
             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, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             self.copyAct.triggered.connect(self.__copy)
         self.__actions.append(self.copyAct)
         self.cutAct = E5Action(
             self.tr('Cut'),
             UI.PixmapCache.getIcon("editCut.png"),
             self.tr('Cu&t'),
             QKeySequence(self.tr("Ctrl+X", "Edit|Cut")),
 , self, 'webbrowser_edit_cut')
         self.cutAct.setStatusTip(self.tr('Cut the selected text'))
         self.cutAct.setWhatsThis(self.tr(
             """<b>Cut</b>"""
             """<p>Cut the selected text to the clipboard.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.cutAct.triggered.connect(self.__cut)
         self.__actions.append(self.cutAct)
         self.pasteAct = E5Action(
             self.tr('Paste'),
             UI.PixmapCache.getIcon("editPaste.png"),
             self.tr('&Paste'),
             QKeySequence(self.tr("Ctrl+V", "Edit|Paste")),
 , self, 'webbrowser_edit_paste')
         self.pasteAct.setStatusTip(self.tr('Paste text from the clipboard'))
         self.pasteAct.setWhatsThis(self.tr(
             """<b>Paste</b>"""
             """<p>Paste some text from the clipboard.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.pasteAct.triggered.connect(self.__paste)
         self.__actions.append(self.pasteAct)
         self.undoAct = E5Action(
             self.tr('Undo'),
             UI.PixmapCache.getIcon("editUndo.png"),
             self.tr('&Undo'),
             QKeySequence(self.tr("Ctrl+Z", "Edit|Undo")),
 , self, 'webbrowser_edit_undo')
         self.undoAct.setStatusTip(self.tr('Undo the last edit action'))
         self.undoAct.setWhatsThis(self.tr(
             """<b>Undo</b>"""
             """<p>Undo the last edit action.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.undoAct.triggered.connect(self.__undo)
         self.__actions.append(self.undoAct)
         self.redoAct = E5Action(
             self.tr('Redo'),
             UI.PixmapCache.getIcon("editRedo.png"),
             self.tr('&Redo'),
             QKeySequence(self.tr("Ctrl+Shift+Z", "Edit|Redo")),
 , self, 'webbrowser_edit_redo')
         self.redoAct.setStatusTip(self.tr('Redo the last edit action'))
         self.redoAct.setWhatsThis(self.tr(
             """<b>Redo</b>"""
             """<p>Redo the last edit action.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.redoAct.triggered.connect(self.__redo)
         self.__actions.append(self.redoAct)
         self.selectAllAct = E5Action(
             self.tr('Select All'),
             UI.PixmapCache.getIcon("editSelectAll.png"),
             self.tr('&Select All'),
             QKeySequence(self.tr("Ctrl+A", "Edit|Select All")),
 , self, 'webbrowser_edit_select_all')
         self.selectAllAct.setStatusTip(self.tr('Select all text'))
         self.selectAllAct.setWhatsThis(self.tr(
             """<b>Select All</b>"""
             """<p>Select all text of the current browser.</p>"""
         ))
         if not self.__initShortcutsOnly:
             self.selectAllAct.triggered.connect(self.__selectAll)
         self.__actions.append(self.selectAllAct)
         self.findAct = E5Action(
             self.tr('Find...'),
             UI.PixmapCache.getIcon("find.png"),
             self.tr('&Find...'),
             QKeySequence(self.tr("Ctrl+F", "Edit|Find")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             self.findNextAct.triggered.connect(self.__searchWidget.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")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             self.findPrevAct.triggered.connect(
                 self.__searchWidget.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")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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")),
 , self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             self.bookmarksAddAct.triggered.connect(self.__addBookmark)
         self.__actions.append(self.bookmarksAddAct)
         self.bookmarksAddFolderAct = E5Action(
             self.tr('Add Folder'),
             self.tr('Add &Folder...'),
 , 0, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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, self, 'webbrowser_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>"""
         ))
         if not self.__initShortcutsOnly:
             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?'")),
 , self, 'webbrowser_help_whats_this')
         self.whatsThisAct.setStatusTip(self.tr('Context sensitive help'))
 a9a94491c4fd
Changed the code to use QObject.tr() instead of QObject.trUtf8().

Detlev Offenbach <detlev@die-offenbac

Mercurial Repositories > eric / annotate

WebBrowser/WebBrowserWindow.py@fb24ccb25ff5 (annotated)

WebBrowser/WebBrowserWindow.py