eric: Helpviewer/HelpWindow.py@c9982bcd00f8 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2015 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the helpviewer main window.
 """
 from __future__ import unicode_literals
 try:
     str = unicode
 except NameError:
     pass
 import os
 from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QByteArray, QSize, QTimer, \
     QUrl, QThread, QTextCodec
 from PyQt5.QtGui import QDesktopServices, QKeySequence, QFont, QFontMetrics, \
     QIcon
 from PyQt5.QtWidgets import QWidget, QVBoxLayout, QSizePolicy, QDockWidget, \
     QComboBox, QLabel, QSplitter, QMenu, QToolButton, QLineEdit, \
     QApplication, QWhatsThis, QDialog, QHBoxLayout, QProgressBar, QAction, \
     QInputDialog
 from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest
 from PyQt5.QtWebKit import QWebSettings, QWebDatabase, QWebSecurityOrigin
 from PyQt5.QtWebKitWidgets import QWebPage
 try:
     from PyQt5.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
     QTHELP_AVAILABLE = True
 except ImportError:
     QTHELP_AVAILABLE = False
 from .Network.NetworkAccessManager import SSL_AVAILABLE
 from .data import icons_rc          # __IGNORE_WARNING__
 from .data import html_rc           # __IGNORE_WARNING__
 from .data import javascript_rc     # __IGNORE_WARNING__
 from E5Gui.E5Action import E5Action
 from E5Gui import E5MessageBox, E5FileDialog, E5ErrorMessage
 from E5Gui.E5MainWindow import E5MainWindow
 from E5Gui.E5Application import e5App
 from E5Gui.E5ZoomWidget import E5ZoomWidget
 import Preferences
 from Preferences import Shortcuts
 import Utilities
 import UI.PixmapCache
 import UI.Config
 from UI.Info import Version
 class HelpWindow(E5MainWindow):
     """
     Class implementing the web browser main window.
     @signal helpClosed() emitted after the window was requested to close down
     @signal zoomTextOnlyChanged(bool) emitted after the zoom text only setting
         was changed
     """
     zoomTextOnlyChanged = pyqtSignal(bool)
     helpClosed = pyqtSignal()
     privacyChanged = pyqtSignal(bool)
     helpwindows = []
     maxMenuFilePathLen = 75
     _fromEric = False
     useQtHelp = QTHELP_AVAILABLE
     _networkAccessManager = None
     _cookieJar = None
     _helpEngine = None
     _bookmarksManager = None
     _historyManager = None
     _passwordManager = None
     _adblockManager = None
     _downloadManager = None
     _feedsManager = None
     _userAgentsManager = None
     _syncManager = None
     _speedDial = None
     _personalInformationManager = None
     _greaseMonkeyManager = None
     _notification = None
     _featurePermissionManager = None
     _flashCookieManager = None
     _zoomManager = None
     def __init__(self, home, path, parent, name, fromEric=False,
                  initShortcutsOnly=False, searchWord=None):
         """
         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)
         """
         super(HelpWindow, self).__init__(parent)
         self.setObjectName(name)
         self.setWindowTitle(self.tr("eric6 Web Browser"))
         self.fromEric = fromEric
         self.__class__._fromEric = fromEric
         self.initShortcutsOnly = initShortcutsOnly
         self.setWindowIcon(UI.PixmapCache.getIcon("ericWeb.png"))
         self.mHistory = []
         self.__lastConfigurationPageName = ""
         self.__eventMouseButtons = Qt.NoButton
         self.__eventKeyboardModifiers = Qt.NoModifier
         if self.initShortcutsOnly:
             self.__initActions()
         else:
             from .SearchWidget import SearchWidget
             from .HelpTocWidget import HelpTocWidget
             from .HelpIndexWidget import HelpIndexWidget
             from .HelpSearchWidget import HelpSearchWidget
             from .HelpBrowserWV import HelpBrowser
             from .HelpTabWidget import HelpTabWidget
             from .AdBlock.AdBlockIcon import AdBlockIcon
             from .VirusTotal.VirusTotalApi import VirusTotalAPI
             HelpWindow.setUseQtHelp(self.fromEric)
             if not self.fromEric:
                 self.setStyle(Preferences.getUI("Style"),
                               Preferences.getUI("StyleSheet"))
                 # initialize some SSL stuff
                 from E5Network.E5SslUtilities import initSSL
                 initSSL()
             if self.useQtHelp:
                 self.__helpEngine = \
                     QHelpEngine(os.path.join(Utilities.getConfigDir(),
                                              "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(
                 HelpBrowser.ZoomLevels, HelpBrowser.ZoomLevelDefault)
             self.__zoomWidget.valueChanged.connect(self.__zoomValueChanged)
             self.tabWidget = HelpTabWidget(self)
             self.tabWidget.currentChanged[int].connect(self.__currentChanged)
             self.tabWidget.titleChanged.connect(self.__titleChanged)
             self.tabWidget.showMessage.connect(self.statusBar().showMessage)
             self.tabWidget.browserClosed.connect(self.__browserClosed)
             self.tabWidget.browserZoomValueChanged.connect(
                 self.__zoomWidget.setValue)
             self.findDlg = SearchWidget(self, self)
             centralWidget = QWidget()
             layout = QVBoxLayout()
             layout.setContentsMargins(1, 1, 1, 1)
             layout.addWidget(self.tabWidget)
             layout.addWidget(self.findDlg)
             self.tabWidget.setSizePolicy(
                 QSizePolicy.Preferred, QSizePolicy.Expanding)
             centralWidget.setLayout(layout)
             self.setCentralWidget(centralWidget)
             self.findDlg.hide()
             if self.useQtHelp:
                 # setup the TOC widget
                 self.__tocWindow = HelpTocWidget(self.__helpEngine, self)
                 self.__tocDock = QDockWidget(self.tr("Contents"), self)
                 self.__tocDock.setObjectName("TocWindow")
                 self.__tocDock.setWidget(self.__tocWindow)
                 self.addDockWidget(Qt.LeftDockWidgetArea, self.__tocDock)
                 # setup the index widget
                 self.__indexWindow = HelpIndexWidget(self.__helpEngine, self)
                 self.__indexDock = QDockWidget(self.tr("Index"), self)
                 self.__indexDock.setObjectName("IndexWindow")
                 self.__indexDock.setWidget(self.__indexWindow)
                 self.addDockWidget(Qt.LeftDockWidgetArea, self.__indexDock)
                 # setup the search widget
                 self.__searchWord = searchWord
                 self.__indexing = False
                 self.__indexingProgress = None
                 self.__searchEngine = self.__helpEngine.searchEngine()
                 self.__searchEngine.indexingStarted.connect(
                     self.__indexingStarted)
                 self.__searchEngine.indexingFinished.connect(
                     self.__indexingFinished)
                 self.__searchWindow = HelpSearchWidget(
                     self.__searchEngine, self)
                 self.__searchDock = QDockWidget(self.tr("Search"), self)
                 self.__searchDock.setObjectName("SearchWindow")
                 self.__searchDock.setWidget(self.__searchWindow)
                 self.addDockWidget(Qt.LeftDockWidgetArea, self.__searchDock)
             if Preferences.getHelp("SaveGeometry"):
                 g = Preferences.getGeometry("HelpViewerGeometry")
             else:
                 g = QByteArray()
             if g.isEmpty():
                 s = QSize(800, 800)
                 self.resize(s)
             else:
                 self.restoreGeometry(g)
             self.__setIconDatabasePath()
             self.__initWebSettings()
             self.__initActions()
             self.__initMenus()
             self.__initToolbars()
             self.historyManager()
             syncMgr = self.syncManager()
             syncMgr.syncMessage.connect(self.statusBar().showMessage)
             syncMgr.syncError.connect(self.statusBar().showMessage)
             self.tabWidget.newBrowser(home)
             self.tabWidget.currentBrowser().setFocus()
             self.__class__.helpwindows.append(self)
             self.__adBlockIcon = AdBlockIcon(self)
             self.statusBar().addPermanentWidget(self.__adBlockIcon)
             self.__adBlockIcon.setEnabled(
                 Preferences.getHelp("AdBlockEnabled"))
             self.tabWidget.currentChanged[int].connect(
                 self.__adBlockIcon.currentChanged)
             self.tabWidget.sourceChanged.connect(
                 self.__adBlockIcon.sourceChanged)
             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)
                 # index window
                 self.__indexWindow.linkActivated.connect(self.__linkActivated)
                 self.__indexWindow.linksActivated.connect(
                     self.__linksActivated)
                 self.__indexWindow.escapePressed.connect(
                     self.__activateCurrentBrowser)
                 # search window
                 self.__searchWindow.linkActivated.connect(
                     self.__linkActivated)
                 self.__searchWindow.escapePressed.connect(
                     self.__activateCurrentBrowser)
             state = Preferences.getHelp("HelpViewerState")
             self.restoreState(state)
             self.__initHelpDb()
             self.__virusTotal = VirusTotalAPI(self)
             self.__virusTotal.submitUrlError.connect(
                 self.__virusTotalSubmitUrlError)
             self.__virusTotal.urlScanReport.connect(
                 self.__virusTotalUrlScanReport)
             self.__virusTotal.fileScanReport.connect(
                 self.__virusTotalFileScanReport)
             self.__previewer = None
             self.__shutdownCalled = False
             self.flashCookieManager()
             if self.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 __setIconDatabasePath(self, enable=True):
         """
         Private method to set the favicons path.
         @param enable flag indicating to enabled icon storage (boolean)
         """
         if enable:
             iconDatabasePath = os.path.join(Utilities.getConfigDir(),
                                             "browser", "favicons")
             if not os.path.exists(iconDatabasePath):
                 os.makedirs(iconDatabasePath)
         else:
             iconDatabasePath = ""   # setting an empty path disables it
         QWebSettings.setIconDatabasePath(iconDatabasePath)
     def __initWebSettings(self):
         """
         Private method to set the global web settings.
         """
         standardFont = Preferences.getHelp("StandardFont")
         fixedFont = Preferences.getHelp("FixedFont")
         settings = QWebSettings.globalSettings()
         settings.setAttribute(QWebSettings.DeveloperExtrasEnabled, True)
         settings.setFontFamily(QWebSettings.StandardFont,
                                standardFont.family())
         settings.setFontSize(QWebSettings.DefaultFontSize,
                              standardFont.pointSize())
         settings.setFontFamily(QWebSettings.FixedFont, fixedFont.family())
         settings.setFontSize(QWebSettings.DefaultFixedFontSize,
                              fixedFont.pointSize())
         styleSheet = Preferences.getHelp("UserStyleSheet")
         settings.setUserStyleSheetUrl(self.__userStyleSheet(styleSheet))
         settings.setAttribute(
             QWebSettings.AutoLoadImages,
             Preferences.getHelp("AutoLoadImages"))
         settings.setAttribute(
             QWebSettings.JavaEnabled,
             Preferences.getHelp("JavaEnabled"))
         settings.setAttribute(
             QWebSettings.JavascriptEnabled,
             Preferences.getHelp("JavaScriptEnabled"))
         settings.setAttribute(
             QWebSettings.JavascriptCanOpenWindows,
             Preferences.getHelp("JavaScriptCanOpenWindows"))
         settings.setAttribute(
             QWebSettings.JavascriptCanAccessClipboard,
             Preferences.getHelp("JavaScriptCanAccessClipboard"))
         settings.setAttribute(
             QWebSettings.PluginsEnabled,
             Preferences.getHelp("PluginsEnabled"))
         if hasattr(QWebSettings, "PrintElementBackgrounds"):
             settings.setAttribute(
                 QWebSettings.PrintElementBackgrounds,
                 Preferences.getHelp("PrintBackgrounds"))
         if hasattr(QWebSettings, "setOfflineStoragePath"):
             settings.setAttribute(
                 QWebSettings.OfflineStorageDatabaseEnabled,
                 Preferences.getHelp("OfflineStorageDatabaseEnabled"))
             webDatabaseDir = os.path.join(
                 Utilities.getConfigDir(), "browser", "webdatabases")
             if not os.path.exists(webDatabaseDir):
                 os.makedirs(webDatabaseDir)
             settings.setOfflineStoragePath(webDatabaseDir)
             settings.setOfflineStorageDefaultQuota(
                 Preferences.getHelp("OfflineStorageDatabaseQuota") *
 * 1024)
         if hasattr(QWebSettings, "OfflineWebApplicationCacheEnabled"):
             settings.setAttribute(
                 QWebSettings.OfflineWebApplicationCacheEnabled,
                 Preferences.getHelp("OfflineWebApplicationCacheEnabled"))
             appCacheDir = os.path.join(
                 Utilities.getConfigDir(), "browser", "webappcaches")
             if not os.path.exists(appCacheDir):
                 os.makedirs(appCacheDir)
             settings.setOfflineWebApplicationCachePath(appCacheDir)
             settings.setOfflineWebApplicationCacheQuota(
                 Preferences.getHelp("OfflineWebApplicationCacheQuota") *
 * 1024)
         if hasattr(QWebSettings, "LocalStorageEnabled"):
             settings.setAttribute(
                 QWebSettings.LocalStorageEnabled,
                 Preferences.getHelp("LocalStorageEnabled"))
             localStorageDir = os.path.join(
                 Utilities.getConfigDir(), "browser", "weblocalstorage")
             if not os.path.exists(localStorageDir):
                 os.makedirs(localStorageDir)
             settings.setLocalStoragePath(localStorageDir)
         if hasattr(QWebSettings, "DnsPrefetchEnabled"):
             settings.setAttribute(
                 QWebSettings.DnsPrefetchEnabled,
                 Preferences.getHelp("DnsPrefetchEnabled"))
         if hasattr(QWebSettings, "defaultTextEncoding"):
             settings.setDefaultTextEncoding(
                 Preferences.getHelp("DefaultTextEncoding"))
         if hasattr(QWebSettings, "SpatialNavigationEnabled"):
             settings.setAttribute(
                 QWebSettings.SpatialNavigationEnabled,
                 Preferences.getHelp("SpatialNavigationEnabled"))
         if hasattr(QWebSettings, "LinksIncludedInFocusChain"):
             settings.setAttribute(
                 QWebSettings.LinksIncludedInFocusChain,
                 Preferences.getHelp("LinksIncludedInFocusChain"))
         if hasattr(QWebSettings, "LocalContentCanAccessRemoteUrls"):
             settings.setAttribute(
                 QWebSettings.LocalContentCanAccessRemoteUrls,
                 Preferences.getHelp("LocalContentCanAccessRemoteUrls"))
         if hasattr(QWebSettings, "LocalContentCanAccessFileUrls"):
             settings.setAttribute(
                 QWebSettings.LocalContentCanAccessFileUrls,
                 Preferences.getHelp("LocalContentCanAccessFileUrls"))
         if hasattr(QWebSettings, "XSSAuditingEnabled"):
             settings.setAttribute(
                 QWebSettings.XSSAuditingEnabled,
                 Preferences.getHelp("XSSAuditingEnabled"))
         if hasattr(QWebSettings, "SiteSpecificQuirksEnabled"):
             settings.setAttribute(
                 QWebSettings.SiteSpecificQuirksEnabled,
                 Preferences.getHelp("SiteSpecificQuirksEnabled"))
         QWebSecurityOrigin.addLocalScheme("eric")
     def __initActions(self):
         """
         Private method to define the user interface actions.
         """
         # list of all actions
         self.__actions = []
         self.newTabAct = E5Action(
             self.tr('New Tab'),
             UI.PixmapCache.getIcon("tabNew.png"),
             self.tr('&New Tab'),
             QKeySequence(self.tr("Ctrl+T", "File|New Tab")),
 , self, 'help_file_new_tab')
         self.newTabAct.setStatusTip(self.tr('Open a new help window tab'))
         self.newTabAct.setWhatsThis(self.tr(
             """<b>New Tab</b>"""
             """<p>This opens a new help window tab.</p>"""
         ))
         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, 'help_file_new_window')
         self.newAct.setStatusTip(self.tr('Open a new help browser window'))
         self.newAct.setWhatsThis(self.tr(
             """<b>New Window</b>"""
             """<p>This opens a new help browser window.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.newAct.triggered.connect(self.newWindow)
         self.__actions.append(self.newAct)
         self.openAct = E5Action(
             self.tr('Open File'),
             UI.PixmapCache.getIcon("open.png"),
             self.tr('&Open File'),
             QKeySequence(self.tr("Ctrl+O", "File|Open")),
 , self, 'help_file_open')
         self.openAct.setStatusTip(self.tr('Open a help file for display'))
         self.openAct.setWhatsThis(self.tr(
             """<b>Open File</b>"""
             """<p>This opens a new help file for display."""
             """ It pops up a file selection dialog.</p>"""
         ))
         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, 'help_file_open_tab')
         self.openTabAct.setStatusTip(
             self.tr('Open a help file for display in a new tab'))
         self.openTabAct.setWhatsThis(self.tr(
             """<b>Open File in New Tab</b>"""
             """<p>This opens a new help file for display in a new tab."""
             """ It pops up a file selection dialog.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.openTabAct.triggered.connect(self.__openFileNewTab)
         self.__actions.append(self.openTabAct)
         self.saveAsAct = E5Action(
             self.tr('Save As'),
             UI.PixmapCache.getIcon("fileSaveAs.png"),
             self.tr('&Save As...'),
             QKeySequence(self.tr("Shift+Ctrl+S", "File|Save As")),
 , self, 'help_file_save_as')
         self.saveAsAct.setStatusTip(
             self.tr('Save the current page to disk'))
         self.saveAsAct.setWhatsThis(self.tr(
             """<b>Save As...</b>"""
             """<p>Saves the current page to disk.</p>"""
         ))
         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, 'help_file_save_page_screen')
         self.savePageScreenAct.setStatusTip(
             self.tr('Save the current page as a screen shot'))
         self.savePageScreenAct.setWhatsThis(self.tr(
             """<b>Save Page Screen...</b>"""
             """<p>Saves the current page as a screen shot.</p>"""
         ))
         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, 'help_file_save_visible_page_screen')
         self.saveVisiblePageScreenAct.setStatusTip(
             self.tr('Save the visible part of the current page as a'
                     ' screen shot'))
         self.saveVisiblePageScreenAct.setWhatsThis(self.tr(
             """<b>Save Visible Page Screen...</b>"""
             """<p>Saves the visible part of the current page as a"""
             """ screen shot.</p>"""
         ))
         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, 'help_file_import_bookmarks')
         self.importBookmarksAct.setStatusTip(
             self.tr('Import bookmarks from other browsers'))
         self.importBookmarksAct.setWhatsThis(self.tr(
             """<b>Import Bookmarks</b>"""
             """<p>Import bookmarks from other browsers.</p>"""
         ))
         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, 'help_file_export_bookmarks')
         self.exportBookmarksAct.setStatusTip(
             self.tr('Export the bookmarks into a file'))
         self.exportBookmarksAct.setWhatsThis(self.tr(
             """<b>Export Bookmarks</b>"""
             """<p>Export the bookmarks into a file.</p>"""
         ))
         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, 'help_file_print')
         self.printAct.setStatusTip(self.tr('Print the displayed help'))
         self.printAct.setWhatsThis(self.tr(
             """<b>Print</b>"""
             """<p>Print the displayed help text.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.printAct.triggered.connect(self.tabWidget.printBrowser)
         self.__actions.append(self.printAct)
         self.printPdfAct = E5Action(
             self.tr('Print as PDF'),
             UI.PixmapCache.getIcon("printPdf.png"),
             self.tr('Print as PDF'),
 , 0, self, 'help_file_print_pdf')
         self.printPdfAct.setStatusTip(self.tr(
             'Print the displayed help as PDF'))
         self.printPdfAct.setWhatsThis(self.tr(
             """<b>Print as PDF</b>"""
             """<p>Print the displayed help text as a PDF file.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.printPdfAct.triggered.connect(
                 self.tabWidget.printBrowserPdf)
         self.__actions.append(self.printPdfAct)
         self.printPreviewAct = E5Action(
             self.tr('Print Preview'),
             UI.PixmapCache.getIcon("printPreview.png"),
             self.tr('Print Preview'),
 , 0, self, 'help_file_print_preview')
         self.printPreviewAct.setStatusTip(self.tr(
             'Print preview of the displayed help'))
         self.printPreviewAct.setWhatsThis(self.tr(
             """<b>Print Preview</b>"""
             """<p>Print preview of the displayed help text.</p>"""
         ))
         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, 'help_file_close')
         self.closeAct.setStatusTip(self.tr(
             'Close the current help window'))
         self.closeAct.setWhatsThis(self.tr(
             """<b>Close</b>"""
             """<p>Closes the current help window.</p>"""
         ))
         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, 'help_file_close_all')
         self.closeAllAct.setStatusTip(self.tr('Close all help windows'))
         self.closeAllAct.setWhatsThis(self.tr(
             """<b>Close All</b>"""
             """<p>Closes all help windows except the first one.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.closeAllAct.triggered.connect(
                 self.tabWidget.closeAllBrowsers)
         self.__actions.append(self.closeAllAct)
         self.privateBrowsingAct = E5Action(
             self.tr('Private Browsing'),
             UI.PixmapCache.getIcon("privateBrowsing.png"),
             self.tr('Private &Browsing'),
 , 0, self, 'help_file_private_browsing')
         self.privateBrowsingAct.setStatusTip(self.tr('Private Browsing'))
         self.privateBrowsingAct.setWhatsThis(self.tr(
             """<b>Private Browsing</b>"""
             """<p>Enables private browsing. In this mode no history is"""
             """ recorded anymore.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.privateBrowsingAct.triggered.connect(
                 self.__privateBrowsing)
         self.privateBrowsingAct.setCheckable(True)
         self.__actions.append(self.privateBrowsingAct)
         self.exitAct = E5Action(
             self.tr('Quit'),
             UI.PixmapCache.getIcon("exit.png"),
             self.tr('&Quit'),
             QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
 , self, 'help_file_quit')
         self.exitAct.setStatusTip(self.tr('Quit the eric6 Web Browser'))
         self.exitAct.setWhatsThis(self.tr(
             """<b>Quit</b>"""
             """<p>Quit the eric6 Web Browser.</p>"""
         ))
         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")),
             QKeySequence(self.tr("Backspace", "Go|Backward")),
             self, 'help_go_backward')
         self.backAct.setStatusTip(self.tr('Move one help screen backward'))
         self.backAct.setWhatsThis(self.tr(
             """<b>Backward</b>"""
             """<p>Moves one help screen backward. If none is"""
             """ available, this action is disabled.</p>"""
         ))
         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")),
             QKeySequence(self.tr("Shift+Backspace", "Go|Forward")),
             self, 'help_go_foreward')
         self.forwardAct.setStatusTip(self.tr(
             'Move one help screen forward'))
         self.forwardAct.setWhatsThis(self.tr(
             """<b>Forward</b>"""
             """<p>Moves one help screen forward. If none is"""
             """ available, this action is disabled.</p>"""
         ))
         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, 'help_go_home')
         self.homeAct.setStatusTip(self.tr(
             'Move to the initial help screen'))
         self.homeAct.setWhatsThis(self.tr(
             """<b>Home</b>"""
             """<p>Moves to the initial help screen.</p>"""
         ))
         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, 'help_go_reload')
         self.reloadAct.setStatusTip(self.tr(
             'Reload the current help screen'))
         self.reloadAct.setWhatsThis(self.tr(
             """<b>Reload</b>"""
             """<p>Reloads the current help screen.</p>"""
         ))
         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, 'help_go_stop')
         self.stopAct.setStatusTip(self.tr('Stop loading'))
         self.stopAct.setWhatsThis(self.tr(
             """<b>Stop</b>"""
             """<p>Stops loading of the current tab.</p>"""
         ))
         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, 'help_edit_copy')
         self.copyAct.setStatusTip(self.tr('Copy the selected text'))
         self.copyAct.setWhatsThis(self.tr(
             """<b>Copy</b>"""
             """<p>Copy the selected text to the clipboard.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.copyAct.triggered.connect(self.__copy)
         self.__actions.append(self.copyAct)
         self.findAct = E5Action(
             self.tr('Find...'),
             UI.PixmapCache.getIcon("find.png"),
             self.tr('&Find...'),
             QKeySequence(self.tr("Ctrl+F", "Edit|Find")),
 , self, 'help_edit_find')
         self.findAct.setStatusTip(self.tr('Find text in page'))
         self.findAct.setWhatsThis(self.tr(
             """<b>Find</b>"""
             """<p>Find text in the current page.</p>"""
         ))
         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, 'help_edit_find_next')
         self.findNextAct.setStatusTip(self.tr(
             'Find next occurrence of text in page'))
         self.findNextAct.setWhatsThis(self.tr(
             """<b>Find next</b>"""
             """<p>Find the next occurrence of text in the current page.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.findNextAct.triggered.connect(self.findDlg.findNext)
         self.__actions.append(self.findNextAct)
         self.findPrevAct = E5Action(
             self.tr('Find previous'),
             UI.PixmapCache.getIcon("findPrev.png"),
             self.tr('Find &previous'),
             QKeySequence(self.tr("Shift+F3", "Edit|Find previous")),
 , self, 'help_edit_find_previous')
         self.findPrevAct.setStatusTip(
             self.tr('Find previous occurrence of text in page'))
         self.findPrevAct.setWhatsThis(self.tr(
             """<b>Find previous</b>"""
             """<p>Find the previous occurrence of text in the current"""
             """ page.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.findPrevAct.triggered.connect(self.findDlg.findPrevious)
         self.__actions.append(self.findPrevAct)
         self.bookmarksManageAct = E5Action(
             self.tr('Manage Bookmarks'),
             self.tr('&Manage Bookmarks...'),
             QKeySequence(self.tr("Ctrl+Shift+B", "Help|Manage bookmarks")),
 , self, 'help_bookmarks_manage')
         self.bookmarksManageAct.setStatusTip(self.tr(
             'Open a dialog to manage the bookmarks.'))
         self.bookmarksManageAct.setWhatsThis(self.tr(
             """<b>Manage Bookmarks...</b>"""
             """<p>Open a dialog to manage the bookmarks.</p>"""
         ))
         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, 'help_bookmark_add')
         self.bookmarksAddAct.setIconVisibleInMenu(False)
         self.bookmarksAddAct.setStatusTip(self.tr(
             'Open a dialog to add a bookmark.'))
         self.bookmarksAddAct.setWhatsThis(self.tr(
             """<b>Add Bookmark</b>"""
             """<p>Open a dialog to add the current URL as a bookmark.</p>"""
         ))
         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, 'help_bookmark_show_all')
         self.bookmarksAddFolderAct.setStatusTip(self.tr(
             'Open a dialog to add a new bookmarks folder.'))
         self.bookmarksAddFolderAct.setWhatsThis(self.tr(
             """<b>Add Folder...</b>"""
             """<p>Open a dialog to add a new bookmarks folder.</p>"""
         ))
         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, 'help_bookmark_all_tabs')
         self.bookmarksAllTabsAct.setStatusTip(self.tr(
             'Bookmark all open tabs.'))
         self.bookmarksAllTabsAct.setWhatsThis(self.tr(
             """<b>Bookmark All Tabs...</b>"""
             """<p>Open a dialog to add a new bookmarks folder for"""
             """ all open tabs.</p>"""
         ))
         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, 'help_help_whats_this')
         self.whatsThisAct.setStatusTip(self.tr('Context sensitive help'))
         self.whatsThisAct.setWhatsThis(self.tr(
             """<b>Display context sensitive help</b>"""
             """<p>In What's This? mode, the mouse cursor shows an arrow"""
             """ with a question mark, and you can click on the interface"""
             """ elements to get a short description of what they do and how"""
             """ to use them. In dialogs, this feature can be accessed using"""
             """ the context help button in the titlebar.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.whatsThisAct.triggered.connect(self.__whatsThis)
         self.__actions.append(self.whatsThisAct)
         self.aboutAct = E5Action(
             self.tr('About'),
             self.tr('&About'),
 , 0, self, 'help_help_about')
         self.aboutAct.setStatusTip(self.tr(
             'Display information about this software'))
         self.aboutAct.setWhatsThis(self.tr(
             """<b>About</b>"""
             """<p>Display some information about this software.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.aboutAct.triggered.connect(self.__about)
         self.__actions.append(self.aboutAct)
         self.aboutQtAct = E5Action(
             self.tr('About Qt'),
             self.tr('About &Qt'),
 , 0, self, 'help_help_about_qt')
         self.aboutQtAct.setStatusTip(
             self.tr('Display information about the Qt toolkit'))
         self.aboutQtAct.setWhatsThis(self.tr(
             """<b>About Qt</b>"""
             """<p>Display some information about the Qt toolkit.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.aboutQtAct.triggered.connect(self.__aboutQt)
         self.__actions.append(self.aboutQtAct)
         self.zoomInAct = E5Action(
             self.tr('Zoom in'),
             UI.PixmapCache.getIcon("zoomIn.png"),
             self.tr('Zoom &in'),
             QKeySequence(self.tr("Ctrl++", "View|Zoom in")),
             QKeySequence(self.tr("Zoom In", "View|Zoom in")),
             self, 'help_view_zoom_in')
         self.zoomInAct.setStatusTip(self.tr('Zoom in on the text'))
         self.zoomInAct.setWhatsThis(self.tr(
             """<b>Zoom in</b>"""
             """<p>Zoom in on the text. This makes the text bigger.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.zoomInAct.triggered.connect(self.__zoomIn)
         self.__actions.append(self.zoomInAct)
         self.zoomOutAct = E5Action(
             self.tr('Zoom out'),
             UI.PixmapCache.getIcon("zoomOut.png"),
             self.tr('Zoom &out'),
             QKeySequence(self.tr("Ctrl+-", "View|Zoom out")),
             QKeySequence(self.tr("Zoom Out", "View|Zoom out")),
             self, 'help_view_zoom_out')
         self.zoomOutAct.setStatusTip(self.tr('Zoom out on the text'))
         self.zoomOutAct.setWhatsThis(self.tr(
             """<b>Zoom out</b>"""
             """<p>Zoom out on the text. This makes the text smaller.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.zoomOutAct.triggered.connect(self.__zoomOut)
         self.__actions.append(self.zoomOutAct)
         self.zoomResetAct = E5Action(
             self.tr('Zoom reset'),
             UI.PixmapCache.getIcon("zoomReset.png"),
             self.tr('Zoom &reset'),
             QKeySequence(self.tr("Ctrl+0", "View|Zoom reset")),
 , self, 'help_view_zoom_reset')
         self.zoomResetAct.setStatusTip(self.tr(
             'Reset the zoom of the text'))
         self.zoomResetAct.setWhatsThis(self.tr(
             """<b>Zoom reset</b>"""
             """<p>Reset the zoom of the text. """
             """This sets the zoom factor to 100%.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.zoomResetAct.triggered.connect(self.__zoomReset)
         self.__actions.append(self.zoomResetAct)
         if hasattr(QWebSettings, 'ZoomTextOnly'):
             self.zoomTextOnlyAct = E5Action(
                 self.tr('Zoom text only'),
                 self.tr('Zoom &text only'),
 , 0, self, 'help_view_zoom_text_only')
             self.zoomTextOnlyAct.setCheckable(True)
             self.zoomTextOnlyAct.setStatusTip(self.tr(
                 'Zoom text only; pictures remain constant'))
             self.zoomTextOnlyAct.setWhatsThis(self.tr(
                 """<b>Zoom text only</b>"""
                 """<p>Zoom text only; pictures remain constant.</p>"""
             ))
             if not self.initShortcutsOnly:
                 self.zoomTextOnlyAct.triggered[bool].connect(
                     self.__zoomTextOnly)
             self.__actions

Mercurial Repositories > eric / annotate

Helpviewer/HelpWindow.py@c9982bcd00f8 (annotated)

Helpviewer/HelpWindow.py