eric: Helpviewer/HelpWindow.py@1695e7a2db54 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2010 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the helpviewer main window.
 """
 import os
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from PyQt4.QtWebKit import QWebSettings, QWebDatabase, QWebSecurityOrigin
 from PyQt4.QtHelp import QHelpEngine, QHelpEngineCore, QHelpSearchQuery
 from .SearchWidget import SearchWidget
 from .HelpBrowserWV import HelpBrowser
 from .HelpTocWidget import HelpTocWidget
 from .HelpIndexWidget import HelpIndexWidget
 from .HelpSearchWidget import HelpSearchWidget
 from .HelpTopicDialog import HelpTopicDialog
 from .QtHelpDocumentationDialog import QtHelpDocumentationDialog
 from .QtHelpFiltersDialog import QtHelpFiltersDialog
 from .HelpDocsInstaller import HelpDocsInstaller
 from .HelpWebSearchWidget import HelpWebSearchWidget
 from .HelpClearPrivateDataDialog import HelpClearPrivateDataDialog
 from .HelpLanguagesDialog import HelpLanguagesDialog
 from .CookieJar.CookieJar import CookieJar
 from .CookieJar.CookiesConfigurationDialog import CookiesConfigurationDialog
 from .Bookmarks.BookmarksManager import BookmarksManager
 from .Bookmarks.BookmarksMenu import BookmarksMenuBarMenu
 from .Bookmarks.BookmarksToolBar import BookmarksToolBar
 from .Bookmarks.BookmarkNode import BookmarkNode
 from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 from .Bookmarks.BookmarksDialog import BookmarksDialog
 from .History.HistoryManager import HistoryManager
 from .History.HistoryMenu import HistoryMenu
 from .History.HistoryCompleter import HistoryCompletionModel, HistoryCompleter
 from .Passwords.PasswordManager import PasswordManager
 from .Network.NetworkAccessManager import NetworkAccessManager
 from .AdBlock.AdBlockManager import AdBlockManager
 from .OfflineStorage.OfflineStorageConfigDialog import OfflineStorageConfigDialog
 from .UserAgent.UserAgentMenu import UserAgentMenu
 from E5Gui.E5TabWidget import E5TabWidget
 from E5Gui.E5Action import E5Action
 from E5Network.E5NetworkMonitor import E5NetworkMonitor
 import Preferences
 from Preferences import Shortcuts
 from Preferences.ConfigurationDialog import ConfigurationDialog
 import Utilities
 import UI.PixmapCache
 import UI.Config
 from eric5config import getConfig
 class HelpWindow(QMainWindow):
     """
     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
     """
     helpwindows = []
     maxMenuFilePathLen = 75
     _networkAccessManager = None
     _cookieJar = None
     _helpEngine = None
     _bookmarksManager = None
     _historyManager = None
     _passwordManager = None
     _adblockManager = 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 eric5 (boolean)
         @keyparam initShortcutsOnly flag indicating to just initialize the keyboard
             shortcuts (boolean)
         @keyparam searchWord word to search for (string)
         """
         QMainWindow.__init__(self, parent)
         self.setObjectName(name)
         self.setAttribute(Qt.WA_DeleteOnClose)
         self.setWindowTitle(self.trUtf8("eric5 Web Browser"))
         self.fromEric = fromEric
         self.initShortcutsOnly = initShortcutsOnly
         self.setWindowIcon(UI.PixmapCache.getIcon("eric.png"))
         self.mHistory = []
         self.pathCombo = None
         if self.initShortcutsOnly:
             self.__initActions()
         else:
             self.__helpEngine = \
                 QHelpEngine(os.path.join(Utilities.getConfigDir(),
                                          "browser", "eric5help.qhc"), self)
             self.connect(self.__helpEngine, SIGNAL("warning(const QString&)"),
                          self.__warning)
             self.__helpInstaller = None
             # Attributes for WebKit based browser
             self.__progressBar = None
             self.tabContextMenuIndex = -1
             self.tabWidget = E5TabWidget(self, dnd = True)
             self.connect(self.tabWidget, SIGNAL('currentChanged(int)'),
                 self.__currentChanged)
             self.tabWidget.setTabContextMenuPolicy(Qt.CustomContextMenu)
             self.tabWidget.customTabContextMenuRequested.connect(self.__showContextMenu)
             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()
             # setup the TOC widget
             self.__tocWindow = HelpTocWidget(self.__helpEngine, self)
             self.__tocDock = QDockWidget(self.trUtf8("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.trUtf8("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.connect(self.__searchEngine, SIGNAL("indexingStarted()"),
                          self.__indexingStarted)
             self.connect(self.__searchEngine, SIGNAL("indexingFinished()"),
                          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.rightCornerWidget = QWidget(self)
             self.rightCornerWidgetLayout = QHBoxLayout(self.rightCornerWidget)
             self.rightCornerWidgetLayout.setMargin(0)
             self.rightCornerWidgetLayout.setSpacing(0)
             self.__navigationMenu = QMenu(self)
             self.connect(self.__navigationMenu, SIGNAL("aboutToShow()"),
                          self.__showNavigationMenu)
             self.connect(self.__navigationMenu, SIGNAL("triggered(QAction*)"),
                          self.__navigationMenuTriggered)
             self.navigationButton = QToolButton(self.tabWidget)
             self.navigationButton.setIcon(UI.PixmapCache.getIcon("1downarrow.png"))
             self.navigationButton.setToolTip(self.trUtf8("Show a navigation menu"))
             self.navigationButton.setPopupMode(QToolButton.InstantPopup)
             self.navigationButton.setMenu(self.__navigationMenu)
             self.navigationButton.setEnabled(False)
             self.rightCornerWidgetLayout.addWidget(self.navigationButton)
             if Preferences.getUI("SingleCloseButton") or \
                not hasattr(self.tabWidget, 'setTabsClosable'):
                 self.closeButton = QToolButton(self.tabWidget)
                 self.closeButton.setIcon(UI.PixmapCache.getIcon("close.png"))
                 self.closeButton.setToolTip(self.trUtf8("Close the current help window"))
                 self.closeButton.setEnabled(False)
                 self.connect(self.closeButton, SIGNAL("clicked(bool)"), self.__close)
                 self.rightCornerWidgetLayout.addWidget(self.closeButton)
             else:
                 self.tabWidget.setTabsClosable(True)
                 self.connect(self.tabWidget, SIGNAL("tabCloseRequested(int)"),
                     self.__closeAt)
                 self.closeButton = None
             self.tabWidget.setCornerWidget(self.rightCornerWidget, Qt.TopRightCorner)
             self.newTabButton = QToolButton(self.tabWidget)
             self.newTabButton.setIcon(UI.PixmapCache.getIcon("new.png"))
             self.newTabButton.setToolTip(self.trUtf8("Open a new help window tab"))
             self.tabWidget.setCornerWidget(self.newTabButton, Qt.TopLeftCorner)
             self.connect(self.newTabButton, SIGNAL("clicked(bool)"), self.newTab)
             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.__initTabContextMenu()
             self.historyManager()
             self.newBrowser(home)
             self.currentBrowser().setFocus()
             self.__class__.helpwindows.append(self)
             QDesktopServices.setUrlHandler("http", self.__linkActivated)
             QDesktopServices.setUrlHandler("https", self.__linkActivated)
             # setup connections
             # TOC window
             self.connect(self.__tocWindow, SIGNAL("linkActivated(const QUrl&)"),
                          self.__linkActivated)
             self.connect(self.__tocWindow, SIGNAL("escapePressed()"),
                          self.__activateCurrentBrowser)
             # index window
             self.connect(self.__indexWindow, SIGNAL("linkActivated(const QUrl&)"),
                          self.__linkActivated)
             self.connect(self.__indexWindow,
                          SIGNAL("linksActivated"),
                          self.__linksActivated)
             self.connect(self.__indexWindow, SIGNAL("escapePressed()"),
                          self.__activateCurrentBrowser)
             # search window
             self.connect(self.__searchWindow, SIGNAL("linkActivated(const QUrl&)"),
                          self.__linkActivated)
             self.connect(self.__searchWindow, SIGNAL("escapePressed()"),
                          self.__activateCurrentBrowser)
             state = Preferences.getHelp("HelpViewerState")
             self.restoreState(state)
             self.__initHelpDb()
             QTimer.singleShot(0, self.__lookForNewDocumentation)
             if self.__searchWord is not None:
                 QTimer.singleShot(0, self.__searchForWord)
     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")
         if styleSheet:
             settings.setUserStyleSheetUrl(QUrl(styleSheet))
         settings.setAttribute(QWebSettings.AutoLoadImages,
             Preferences.getHelp("AutoLoadImages"))
         settings.setAttribute(QWebSettings.JavaEnabled,
             Preferences.getHelp("JavaEnabled"))
         settings.setAttribute(QWebSettings.JavascriptEnabled,
             Preferences.getHelp("JavaScriptEnabled"))
         settings.setAttribute(QWebSettings.JavascriptCanOpenWindows,
             Preferences.getHelp("JavaScriptCanOpenWindows"))
         settings.setAttribute(QWebSettings.JavascriptCanAccessClipboard,
             Preferences.getHelp("JavaScriptCanAccessClipboard"))
         settings.setAttribute(QWebSettings.PluginsEnabled,
             Preferences.getHelp("PluginsEnabled"))
         if hasattr(QWebSettings, "PrintElementBackgrounds"):
             settings.setAttribute(QWebSettings.PrintElementBackgrounds,
                 Preferences.getHelp("PrintBackgrounds"))
         if hasattr(QWebSettings, "setOfflineStoragePath"):
             settings.setAttribute(QWebSettings.OfflineStorageDatabaseEnabled,
                 Preferences.getHelp("OfflineStorageDatabaseEnabled"))
             webDatabaseDir = os.path.join(
                 Utilities.getConfigDir(), "browser", "webdatabases")
             if not os.path.exists(webDatabaseDir):
                 os.makedirs(webDatabaseDir)
             settings.setOfflineStoragePath(webDatabaseDir)
             settings.setOfflineStorageDefaultQuota(
                 Preferences.getHelp("OfflineStorageDatabaseQuota") * 1024 * 1024)
         if hasattr(QWebSettings, "OfflineWebApplicationCacheEnabled"):
             settings.setAttribute(QWebSettings.OfflineWebApplicationCacheEnabled,
                 Preferences.getHelp("OfflineWebApplicationCacheEnabled"))
             appCacheDir = os.path.join(
                 Utilities.getConfigDir(), "browser", "webappcaches")
             if not os.path.exists(appCacheDir):
                 os.makedirs(appCacheDir)
             settings.setOfflineWebApplicationCachePath(appCacheDir)
             settings.setOfflineWebApplicationCacheQuota(
                 Preferences.getHelp("OfflineWebApplicationCacheQuota") * 1024 * 1024)
         if hasattr(QWebSettings, "LocalStorageEnabled"):
             settings.setAttribute(QWebSettings.LocalStorageEnabled,
                 Preferences.getHelp("LocalStorageEnabled"))
             localStorageDir = os.path.join(
                 Utilities.getConfigDir(), "browser", "weblocalstorage")
             if not os.path.exists(localStorageDir):
                 os.makedirs(localStorageDir)
             settings.setLocalStoragePath(localStorageDir)
         if hasattr(QWebSettings, "DnsPrefetchEnabled"):
             settings.setAttribute(QWebSettings.DnsPrefetchEnabled,
                 Preferences.getHelp("DnsPrefetchEnabled"))
         if hasattr(QWebSettings, "defaultTextEncoding"):
             settings.setDefaultTextEncoding(
                 Preferences.getHelp("DefaultTextEncoding"))
     def __initActions(self):
         """
         Private method to define the user interface actions.
         """
         # list of all actions
         self.__actions = []
         self.newTabAct = E5Action(self.trUtf8('New Tab'),
             UI.PixmapCache.getIcon("new.png"),
             self.trUtf8('&New Tab'),
             QKeySequence(self.trUtf8("Ctrl+T","File|New Tab")),
 , self, 'help_file_new_tab')
         self.newTabAct.setStatusTip(self.trUtf8('Open a new help window tab'))
         self.newTabAct.setWhatsThis(self.trUtf8(
                 """<b>New Tab</b>"""
                 """<p>This opens a new help window tab.</p>"""
         ))
         self.newTabAct.triggered[()].connect(self.newTab)
         self.__actions.append(self.newTabAct)
         self.newAct = E5Action(self.trUtf8('New Window'),
             UI.PixmapCache.getIcon("newWindow.png"),
             self.trUtf8('New &Window'),
             QKeySequence(self.trUtf8("Ctrl+N","File|New Window")),
 , self, 'help_file_new_window')
         self.newAct.setStatusTip(self.trUtf8('Open a new help browser window'))
         self.newAct.setWhatsThis(self.trUtf8(
                 """<b>New Window</b>"""
                 """<p>This opens a new help browser window.</p>"""
         ))
         self.newAct.triggered[()].connect(self.newWindow)
         self.__actions.append(self.newAct)
         self.openAct = E5Action(self.trUtf8('Open File'),
             UI.PixmapCache.getIcon("open.png"),
             self.trUtf8('&Open File'),
             QKeySequence(self.trUtf8("Ctrl+O","File|Open")),
 , self, 'help_file_open')
         self.openAct.setStatusTip(self.trUtf8('Open a help file for display'))
         self.openAct.setWhatsThis(self.trUtf8(
                 """<b>Open File</b>"""
                 """<p>This opens a new help file for display."""
                 """ It pops up a file selection dialog.</p>"""
         ))
         self.openAct.triggered[()].connect(self.__openFile)
         self.__actions.append(self.openAct)
         self.openTabAct = E5Action(self.trUtf8('Open File in New Tab'),
             UI.PixmapCache.getIcon("openNewTab.png"),
             self.trUtf8('Open File in New &Tab'),
             QKeySequence(self.trUtf8("Shift+Ctrl+O","File|Open in new tab")),
 , self, 'help_file_open_tab')
         self.openTabAct.setStatusTip(\
             self.trUtf8('Open a help file for display in a new tab'))
         self.openTabAct.setWhatsThis(self.trUtf8(
                 """<b>Open File in New Tab</b>"""
                 """<p>This opens a new help file for display in a new tab."""
                 """ It pops up a file selection dialog.</p>"""
         ))
         self.openTabAct.triggered[()].connect(self.__openFileNewTab)
         self.__actions.append(self.openTabAct)
         self.saveAsAct = E5Action(self.trUtf8('Save As '),
             UI.PixmapCache.getIcon("fileSaveAs.png"),
             self.trUtf8('&Save As...'),
             QKeySequence(self.trUtf8("Shift+Ctrl+S","File|Save As")),
 , self, 'help_file_save_as')
         self.saveAsAct.setStatusTip(\
             self.trUtf8('Save the current page to disk'))
         self.saveAsAct.setWhatsThis(self.trUtf8(
                 """<b>Save As...</b>"""
                 """<p>Saves the current page to disk.</p>"""
         ))
         self.saveAsAct.triggered[()].connect(self.__savePageAs)
         self.__actions.append(self.saveAsAct)
         bookmarksManager = self.bookmarksManager()
         self.importBookmarksAct = E5Action(self.trUtf8('Import Bookmarks'),
             self.trUtf8('&Import Bookmarks...'),
 , 0, self, 'help_file_import_bookmarks')
         self.importBookmarksAct.setStatusTip(\
             self.trUtf8('Import bookmarks from other browsers'))
         self.importBookmarksAct.setWhatsThis(self.trUtf8(
                 """<b>Import Bookmarks</b>"""
                 """<p>Import bookmarks from other browsers.</p>"""
         ))
         self.importBookmarksAct.triggered[()].connect(bookmarksManager.importBookmarks)
         self.__actions.append(self.importBookmarksAct)
         self.exportBookmarksAct = E5Action(self.trUtf8('Export Bookmarks'),
             self.trUtf8('&Export Bookmarks...'),
 , 0, self, 'help_file_export_bookmarks')
         self.exportBookmarksAct.setStatusTip(\
             self.trUtf8('Export the bookmarks into a file'))
         self.exportBookmarksAct.setWhatsThis(self.trUtf8(
                 """<b>Export Bookmarks</b>"""
                 """<p>Export the bookmarks into a file.</p>"""
         ))
         self.exportBookmarksAct.triggered[()].connect(bookmarksManager.exportBookmarks)
         self.__actions.append(self.exportBookmarksAct)
         self.printAct = E5Action(self.trUtf8('Print'),
             UI.PixmapCache.getIcon("print.png"),
             self.trUtf8('&Print'),
             QKeySequence(self.trUtf8("Ctrl+P","File|Print")),
 , self, 'help_file_print')
         self.printAct.setStatusTip(self.trUtf8('Print the displayed help'))
         self.printAct.setWhatsThis(self.trUtf8(
                 """<b>Print</b>"""
                 """<p>Print the displayed help text.</p>"""
         ))
         self.printAct.triggered[()].connect(self.__printFile)
         self.__actions.append(self.printAct)
         self.printPdfAct = E5Action(self.trUtf8('Print as PDF'),
             UI.PixmapCache.getIcon("printPdf.png"),
             self.trUtf8('Print as PDF'),
 , 0, self, 'help_file_print_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>"""
         ))
         self.printPdfAct.triggered[()].connect(self.__printFilePdf)
         self.__actions.append(self.printPdfAct)
         self.printPreviewAct = E5Action(self.trUtf8('Print Preview'),
             UI.PixmapCache.getIcon("printPreview.png"),
             self.trUtf8('Print Preview'),
 , 0, self, 'help_file_print_preview')
         self.printPreviewAct.setStatusTip(self.trUtf8(
                 'Print preview of the displayed help'))
         self.printPreviewAct.setWhatsThis(self.trUtf8(
                 """<b>Print Preview</b>"""
                 """<p>Print preview of the displayed help text.</p>"""
         ))
         self.printPreviewAct.triggered[()].connect(self.__printPreviewFile)
         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")),
 , self, 'help_file_close')
         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>"""
         ))
         self.closeAct.triggered[()].connect(self.__close)
         self.__actions.append(self.closeAct)
         self.closeAllAct = E5Action(self.trUtf8('Close All'),
             self.trUtf8('Close &All'),
 , 0, self, 'help_file_close_all')
         self.closeAllAct.setStatusTip(self.trUtf8('Close all help windows'))
         self.closeAllAct.setWhatsThis(self.trUtf8(
                 """<b>Close All</b>"""
                 """<p>Closes all help windows except the first one.</p>"""
         ))
         self.closeAllAct.triggered[()].connect(self.__closeAll)
         self.__actions.append(self.closeAllAct)
         self.privateBrowsingAct = E5Action(self.trUtf8('Private Browsing'),
             UI.PixmapCache.getIcon("privateBrowsing.png"),
             self.trUtf8('Private &Browsing'),
 , 0, self, 'help_file_private_browsing')
         self.privateBrowsingAct.setStatusTip(self.trUtf8('Private Browsing'))
         self.privateBrowsingAct.setWhatsThis(self.trUtf8(
                 """<b>Private Browsing</b>"""
                 """<p>Enables private browsing. In this mode no history is"""
                 """ recorded anymore.</p>"""
         ))
         self.privateBrowsingAct.triggered[()].connect(self.__privateBrowsing)
         self.privateBrowsingAct.setCheckable(True)
         self.__actions.append(self.privateBrowsingAct)
         self.exitAct = E5Action(self.trUtf8('Quit'),
             UI.PixmapCache.getIcon("exit.png"),
             self.trUtf8('&Quit'),
             QKeySequence(self.trUtf8("Ctrl+Q","File|Quit")),
 , self, 'help_file_quit')
         self.exitAct.setStatusTip(self.trUtf8('Quit the web browser'))
         self.exitAct.setWhatsThis(self.trUtf8(
                 """<b>Quit</b>"""
                 """<p>Quit the web browser.</p>"""
         ))
         if self.fromEric:
             self.exitAct.triggered[()].connect(self.close)
         else:
             self.exitAct.triggered[()].connect(qApp.closeAllWindows)
         self.__actions.append(self.exitAct)
         self.backAct = E5Action(self.trUtf8('Backward'),
             UI.PixmapCache.getIcon("back.png"),
             self.trUtf8('&Backward'),
             QKeySequence(self.trUtf8("Alt+Left","Go|Backward")),
             QKeySequence(self.trUtf8("Backspace","Go|Backward")),
             self, 'help_go_backward')
         self.backAct.setStatusTip(self.trUtf8('Move one help screen backward'))
         self.backAct.setWhatsThis(self.trUtf8(
                 """<b>Backward</b>"""
                 """<p>Moves one help screen backward. If none is"""
                 """ available, this action is disabled.</p>"""
         ))
         self.backAct.triggered[()].connect(self.__backward)
         self.__actions.append(self.backAct)
         self.forwardAct = E5Action(self.trUtf8('Forward'),
             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.setWhatsThis(self.trUtf8(
                 """<b>Forward</b>"""
                 """<p>Moves one help screen forward. If none is"""
                 """ available, this action is disabled.</p>"""
         ))
         self.forwardAct.triggered[()].connect(self.__forward)
         self.__actions.append(self.forwardAct)
         self.homeAct = E5Action(self.trUtf8('Home'),
             UI.PixmapCache.getIcon("home.png"),
             self.trUtf8('&Home'),
             QKeySequence(self.trUtf8("Ctrl+Home","Go|Home")),
 , self, 'help_go_home')
         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>"""
         ))
         self.homeAct.triggered[()].connect(self.__home)
         self.__actions.append(self.homeAct)
         self.reloadAct = E5Action(self.trUtf8('Reload'),
             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.setWhatsThis(self.trUtf8(
                 """<b>Reload</b>"""
                 """<p>Reloads the current help screen.</p>"""
         ))
         self.reloadAct.triggered[()].connect(self.__reload)
         self.__actions.append(self.reloadAct)
         self.stopAct = E5Action(self.trUtf8('Stop'),
             UI.PixmapCache.getIcon("stopLoading.png"),
             self.trUtf8('&Stop'),
             QKeySequence(self.trUtf8("Ctrl+.","Go|Stop")),
             QKeySequence(self.trUtf8("Esc","Go|Stop")),
             self, 'help_go_stop')
         self.stopAct.setStatusTip(self.trUtf8('Stop loading'))
         self.stopAct.setWhatsThis(self.trUtf8(
                 """<b>Stop</b>"""
                 """<p>Stops loading of the current tab.</p>"""
         ))
         self.stopAct.triggered[()].connect(self.__stopLoading)
         self.__actions.append(self.stopAct)
         self.copyAct = E5Action(self.trUtf8('Copy'),
             UI.PixmapCache.getIcon("editCopy.png"),
             self.trUtf8('&Copy'),
             QKeySequence(self.trUtf8("Ctrl+C","Edit|Copy")),
 , self, 'help_edit_copy')
         self.copyAct.setStatusTip(self.trUtf8('Copy the selected text'))
         self.copyAct.setWhatsThis(self.trUtf8(
                 """<b>Copy</b>"""
                 """<p>Copy the selected text to the clipboard.</p>"""
         ))
         self.copyAct.triggered[()].connect(self.__copy)
         self.__actions.append(self.copyAct)
         self.findAct = E5Action(self.trUtf8('Find...'),
             UI.PixmapCache.getIcon("find.png"),
             self.trUtf8('&Find...'),
             QKeySequence(self.trUtf8("Ctrl+F","Edit|Find")),
 , self, 'help_edit_find')
         self.findAct.setStatusTip(self.trUtf8('Find text in page'))
         self.findAct.setWhatsThis(self.trUtf8(
                 """<b>Find</b>"""
                 """<p>Find text in the current page.</p>"""
         ))
         self.findAct.triggered[()].connect(self.__find)
         self.__actions.append(self.findAct)
         self.findNextAct = E5Action(self.trUtf8('Find next'),
             UI.PixmapCache.getIcon("findNext.png"),
             self.trUtf8('Find &next'),
             QKeySequence(self.trUtf8("F3","Edit|Find next")),
 , self, 'help_edit_find_next')
         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)
         self.findPrevAct = E5Action(self.trUtf8('Find previous'),
             UI.PixmapCache.getIcon("findPrev.png"),
             self.trUtf8('Find &previous'),
             QKeySequence(self.trUtf8("Shift+F3","Edit|Find previous")),
 , 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>"""
         ))
         if not self.initShortcutsOnly:
             self.findPrevAct.triggered[()].connect(self.findDlg.findPrevious)
         self.__actions.append(self.findPrevAct)
         self.bookmarksManageAct = E5Action(self.trUtf8('Manage Bookmarks'),
             self.trUtf8('&Manage Bookmarks...'),
             QKeySequence(self.trUtf8("Ctrl+Shift+B", "Help|Manage bookmarks")),
 , self, 'help_bookmarks_manage')
         self.bookmarksManageAct.setStatusTip(self.trUtf8(
                 'Open a dialog to manage the bookmarks.'))
         self.bookmarksManageAct.setWhatsThis(self.trUtf8(
                 """<b>Manage Bookmarks...</b>"""
                 """<p>Open a dialog to manage the bookmarks.</p>"""
         ))
         self.bookmarksManageAct.triggered[()].connect(self.__showBookmarksDialog)
         self.__actions.append(self.bookmarksManageAct)
         self.bookmarksAddAct = E5Action(self.trUtf8('Add Bookmark'),
             UI.PixmapCache.getIcon("addBookmark.png"),
             self.trUtf8('Add &Bookmark...'),
             QKeySequence(self.trUtf8("Ctrl+D", "Help|Add bookmark")),
 , self, 'help_bookmark_add')
         self.bookmarksAddAct.setIconVisibleInMenu(False)
         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>"""
         ))
         self.bookmarksAddAct.triggered[()].connect(self.__addBookmark)
         self.__actions.append(self.bookmarksAddAct)
         self.bookmarksAddFolderAct = E5Action(self.trUtf8('Add Folder'),
             self.trUtf8('Add &Folder...'),
 , 0, self, 'help_bookmark_show_all')
         self.bookmarksAddFolderAct.setStatusTip(self.trUtf8(
                 'Open a dialog to add a new bookmarks folder.'))
         self.bookmarksAddFolderAct.setWhatsThis(self.trUtf8(
                 """<b>Add Folder...</b>"""
                 """<p>Open a dialog to add a new bookmarks folder.</p>"""
         ))
         self.bookmarksAddFolderAct.triggered[()].connect(self.__addBookmarkFolder)
         self.__actions.append(self.bookmarksAddFolderAct)
         self.bookmarksAllTabsAct = E5Action(self.trUtf8('Bookmark All Tabs'),
             self.trUtf8('Bookmark All Tabs...'),
 , 0, self, 'help_bookmark_all_tabs')
         self.bookmarksAllTabsAct.setStatusTip(self.trUtf8(
                 'Bookmark all open tabs.'))
         self.bookmarksAllTabsAct.setWhatsThis(self.trUtf8(
                 """<b>Bookmark All Tabs...</b>"""
                 """<p>Open a dialog to add a new bookmarks folder for"""
                 """ all open tabs.</p>"""
         ))
         self.bookmarksAllTabsAct.triggered[()].connect(self.__bookmarkAll)
         self.__actions.append(self.bookmarksAllTabsAct)
         self.whatsThisAct = E5Action(self.trUtf8('What\'s This?'),
             UI.PixmapCache.getIcon("whatsThis.png"),
             self.trUtf8('&What\'s This?'),
             QKeySequence(self.trUtf8("Shift+F1","Help|What's This?'")),
 , 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"""
                 """ question mark, and you can click on the interface elements to get"""
                 """ a short description of what they do and how to use them. In"""
                 """ dialogs, this feature can be accessed using the context help button"""
                 """ in the titlebar.</p>"""
         ))
         self.whatsThisAct.triggered[()].connect(self.__whatsThis)
         self.__actions.append(self.whatsThisAct)
         self.aboutAct = E5Action(self.trUtf8('About'),
             self.trUtf8('&About'),
 , 0, self, 'help_help_about')
         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>"""
         ))
         self.aboutAct.triggered[()].connect(self.__about)
         self.__actions.append(self.aboutAct)
         self.aboutQtAct = E5Action(self.trUtf8('About Qt'),
             self.trUtf8('About &Qt'),
 , 0, self, 'help_help_about_qt')
         self.aboutQtAct.setStatusTip(\
             self.trUtf8('Display information about the Qt toolkit'))
         self.aboutQtAct.setWhatsThis(self.trUtf8(
                 """<b>About Qt</b>"""
                 """<p>Display some information about the Qt toolkit.</p>"""
         ))
         self.aboutQtAct.triggered[()].connect(self.__aboutQt)
         self.__actions.append(self.aboutQtAct)
         self.zoomInAct = E5Action(self.trUtf8('Zoom in'),
             UI.PixmapCache.getIcon("zoomIn.png"),
             self.trUtf8('Zoom &in'),
             QKeySequence(self.trUtf8("Ctrl++","View|Zoom in")),
 , self, 'help_view_zoom_in')
         self.zoomInAct.setStatusTip(self.trUtf8('Zoom in on the text'))
         self.zoomInAct.setWhatsThis(self.trUtf8(
                 """<b>Zoom in</b>"""
                 """<p>Zoom in on the text. This makes the text bigger.</p>"""
         ))
         self.zoomInAct.triggered[()].connect(self.__zoomIn)
         self.__actions.append(self.zoomInAct)
         self.zoomOutAct = E5Action(self.trUtf8('Zoom out'),
             UI.PixmapCache.getIcon("zoomOut.png"),
             self.trUtf8('Zoom &out'),
             QKeySequence(self.trUtf8("Ctrl+-","View|Zoom out")),
 , self, 'help_view_zoom_out')
         self.zoomOutAct.setStatusTip(self.trUtf8('Zoom out on the text'))
         self.zoomOutAct.setWhatsThis(self.trUtf8(
                 """<b>Zoom out</b>"""
                 """<p>Zoom out on the text. This makes the text smaller.</p>"""
         ))
         self.zoomOutAct.triggered[()].connect(self.__zoomOut)
         self.__actions.append(self.zoomOutAct)
         self.zoomResetAct = E5Action(self.trUtf8('Zoom reset'),
             UI.PixmapCache.getIcon("zoomReset.png"),
             self.trUtf8('Zoom &reset'),
             QKeySequence(self.trUtf8("Ctrl+0","View|Zoom reset")),
 , self, 'help_view_zoom_reset')
         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>"""
         ))
         self.zoomResetAct.triggered[()].connect(self.__zoomReset)
         self.__actions.append(self.zoomResetAct)
         if hasattr(QWebSettings, 'ZoomTextOnly'):
             self.zoomTextOnlyAct = E5Action(self.trUtf8('Zoom text only'),
                 self.trUtf8('Zoom &text only'),
 , 0, self, 'help_view_zoom_text_only')
             self.zoomTextOnlyAct.setCheckable(True)
             self.zoomTextOnlyAct.setStatusTip(self.trUtf8(
                     'Zoom text only; pictures remain constant'))
             self.zoomTextOnlyAct.setWhatsThis(self.trUtf8(
                     """<b>Zoom text only</b>"""
                     """<p>Zoom text only; pictures remain constant.</p>"""
             ))
             self.connect(self.zoomTextOnlyAct, SIGNAL('triggered(bool)'),
                 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.setWhatsThis(self.trUtf8(
                 """<b>Show page source</b>"""
                 """<p>Show the page source in an editor.</p>"""
         ))
         self.pageSourceAct.triggered[()].connect(self.__showPageSource)
         self.__actions.append(self.pageSourceAct)
         self.addAction(self.pageSourceAct)
         self.fullScreenAct = E5Action(self.trUtf8('Full Screen'),
             UI.PixmapCache.getIcon("windowFullscreen.png"),
             self.trUtf8('&Full Screen'),
             QKeySequence(self.trUtf8('F11')), 0,
             self, 'help_view_full_scree')
         self.fullScreenAct.triggered[()].connect(self.__viewFullScreen)
         self.__actions.append(self.fullScreenAct)
         self.addAction(self.fullScreenAct)
         self.nextTabAct = E5Action(self.trUtf8('Show next tab'),
             self.trUtf8('Show next tab'),
             QKeySequence(self.trUtf8('Ctrl+Alt+Tab')), 0,
             self, 'help_view_next_tab')
         self.nextTabAct.triggered[()].connect(self.__nextTab)
         self.__actions.append(self.nextTabAct)
         self.addAction(self.nextTabAct)
         self.prevTabAct = E5Action(self.trUtf8('Show previous tab'),
             self.trUtf8('Show previous tab'),
             QKeySequence(self.trUtf8('Shift+Ctrl+Alt+Tab')), 0,
             self, 'help_view_previous_tab')
         self.prevTabAct.triggered[()].connect(self.__prevTab)
         self.__actions.append(self.prevTabAct)
         self.addAction(self.prevTabAct)
         self.switchTabAct = E5Action(self.trUtf8('Switch between tabs'),
             self.trUtf8('Switch between tabs'),
             QKeySequence(self.trUtf8('Ctrl+1')), 0,
             self, 'help_switch_tabs')
         self.switchTabAct.triggered[()].connect(self.__switchTab)
         self.__actions.append(self.switchTabAct)
         self.addAction(self.switchTabAct)
         self.prefAct = E5Action(self.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.setWhatsThis(self.trUtf8(
             """<b>Preferences</b>"""
             """<p>Set the configuration items of the application"""
             """ with your prefered values.</p>"""
         ))
         self.prefAct.triggered[()].connect(self.__showPreferences)
         self.__actions.append(self.prefAct)
         self.acceptedLanguagesAct = E5Action(self.trUtf8('Languages'),
             UI.PixmapCache.getIcon("flag.png"),
             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>"""
         ))
         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.setStatusTip(self.trUtf8(
             'Configure cookies handling'))
         self.cookiesAct.setWhatsThis(self.trUtf8(
             """<b>Cookies</b>"""
             """<p>Configure cookies handling.</p>"""
         ))
         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.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.offlineStorageAct.triggered[()].connect(self.__showOfflineStorageConfiguration)
         self.__actions.append(self.offlineStorageAct)
         self.syncTocAct = E5Action(self.trUtf8('Sync with Table of Contents'),
             UI.PixmapCache.getIcon("syncToc.png"),
             self.trUtf8('Sync with Table of Contents'),
 , 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>"""
         ))
         self.syncTocAct.triggered[()].connect(self.__syncTOC)
         self.__actions.append(self.syncTocAct)
         self.showTocAct = E5Action(self.trUtf8('Table of Contents'),
             self.trUtf8('Table of Contents'),
 , 0, self, 'help_show_toc')
         self.showTocAct.setStatusTip(self.trUtf8(
                 'Shows the table of contents window'))
         self.showTocAct.setWhatsThis(self.trUtf8(
                 """<b>Table of Contents</b>"""
                 """<p>Shows the table of contents window.</p>"""
         ))
         self.showTocAct.triggered[()].connect(self.__showTocWindow)
         self.__actions.append(self.showTocAct)
         self.showIndexAct = E5Action(self.trUtf8('Index'),
             self.trUtf8('Index'),
 , 0, self, 'help_show_index')
         self.showIndexAct.setStatusTip(self.trUtf8(
                 'Shows the index window'))
         self.showIndexAct.setWhatsThis(self.trUtf8(
                 """<b>Index</b>"""
                 """<p>Shows the index window.</p>"""
         ))
         self.showIndexAct.triggered[()].connect(self.__showIndexWindow)
         self.__actions.append(self.showIndexAct)
         self.showSearchAct = E5Action(self.trUtf8('Search'),
             self.trUtf8('Search'),
 , 0, self, 'help_show_search')
         self.showSearchAct.setStatusTip(self.trUtf8(
                 'Shows the search window'))
         self.showSearchAct.setWhatsThis(self.trUtf8(
                 """<b>Search</b>"""
                 """<p>Shows the search window.</p>"""
         ))
         self.showSearchAct.triggered[()].connect(self.__showSearchWindow)
         self.__actions.append(self.showSearchAct)
         self.manageQtHelpDocsAct = E5Action(self.trUtf8('Manage QtHelp Documents'),
             self.trUtf8('Manage QtHelp &Documents'),
 , 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>"""
         ))
         self.manageQtHelpDocsAct.triggered[()].connect(self.__manageQtHelpDocumentation)
         self.__actions.append(self.manageQtHelpDocsAct)
         self.manageQtHelpFiltersAct = E5Action(self.trUtf8('Manage QtHelp Filters'),
             self.trUtf8('Manage QtHelp &Filters'),
 , 0, self, 'help_qthelp_filters')
         self.manageQtHelpFiltersAct.setStatusTip(self.trUtf8(
                 'Shows a dialog to manage the QtHelp filters'))
         self.manageQtHelpFiltersAct.setWhatsThis(self.trUtf8(
                 """<b>Manage QtHelp Filters</b>"""
                 """<p>Shows a dialog to manage the QtHelp filters.</p>"""
         ))
         self.manageQtHelpFiltersAct.triggered[()].connect(self.__manageQtHelpFilters)
         self.__actions.append(self.manageQtHelpFiltersAct)
         self.reindexDocumentationAct = E5Action(self.trUtf8('Reindex Documentation'),
             self.trUtf8('&Reindex Documentation'),
 , 0, self, 'help_qthelp_reindex')
         self.reindexDocumentationAct.setStatusTip(self.trUtf8(
                 'Reindexes the documentation set'))
         self.reindexDocumentationAct.setWhatsThis(self.trUtf8(
                 """<b>Reindex Documentation</b>"""
                 """<p>Reindexes the documentation set.</p>"""
         ))
         if not self.initShortcutsOnly:
             self.reindexDocumentationAct.triggered[()].connect(self.__searchEngine.reindexDocumentation)
         self.__actions.append(self.reindexDocumentationAct)
         self.clearPrivateDataAct = E5Action(self.trUtf8('Clear private data'),
                       self.trUtf8('&Clear private data'),
 , 0,
                       self, 'help_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"""
                 """ or the favicons database.</p>"""
         ))
         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,
                       self, 'help_clear_icons_db')
         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>"""
         ))
         self.clearIconsAct.triggered[()].connect(self.__clearIconsDatabase)
         self.__actions.append(self.clearIconsAct)
         self.searchEnginesAct = E5Action(self.trUtf8('Configure Search Engines'),
                       self.trUtf8('Configure Search &Engines...'),
 , 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>"""
         ))
         self.searchEnginesAct.triggered[()].connect(self.__showEnginesConfigurationDialog)
         self.__actions.append(self.searchEnginesAct)
         self.passwordsAct = E5Action(self.trUtf8('Manage Saved Passwords'),
                       self.trUtf8('Manage Saved Passwords...'),
 , 0,
                       self, 'help_manage_passwords')
         self.passwordsAct.setStatusTip(self.trUtf8(
                 'Manage the saved passwords'))
         self.passwordsAct.setWhatsThis(self.trUtf8(
                 """<b>Manage Saved Passwords...</b>"""
                 """<p>Opens a dialog to manage the saved passwords.</p>"""
         ))
         self.passwordsAct.triggered[()].connect(self.__showPasswordsDialog)
         self.__actions.append(self.passwordsAct)
         self.adblockAct = E5Action(self.trUtf8('Ad Block'),
                       self.trUtf8('&Ad Block...'),
 , 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>"""
         ))
         self.adblockAct.triggered[()].connect(self.__showAdBlockDialog)
         self.__actions.append(self.adblockAct)
         self.toolsMonitorAct = E5Action(self.trUtf8('Show Network Monitor'),
                       self.trUtf8('Show &Network Monitor'),
 , 0,
                       self, 'help_tools_network_monitor')
         self.toolsMonitorAct.setStatusTip(self.trUtf8('Show the network monitor dialog'))
         self.toolsMonitorAct.setWhatsThis(self.trUtf8(
                 """<b>Show Network Monitor</b>"""
                 """<p>Shows the network monitor dialog.</p>"""
         ))
         self.toolsMonitorAct.triggered[()].connect(self.__showNetworkMonitor)
         self.__actions.append(self.toolsMonitorAct)
         self.backAct.setEnabled(False)
         self.forwardAct.setEnabled(False)
         # now read the keyboard shortcuts for the actions
         Shortcuts.readShortcuts(helpViewer = self)
     def getActions(self):
         """
         Public method to get a list of all actions.
         @return list of all actions (list of E5Action)
         """
 de9c2efb9d02
Started porting eric4 to Python3

Detlev Offenbach <detl

Mercurial Repositories > eric / annotate

Helpviewer/HelpWindow.py@1695e7a2db54 (annotated)

Helpviewer/HelpWindow.py