eric: comparison eric7/WebBrowser/WebBrowserWindow.py

-:8a7677a63c8d
+:68ec9c3d4de5
 from PyQt6.QtHelp import QHelpEngine, QHelpEngineCore
 QTHELP_AVAILABLE = True
 except ImportError:
 QTHELP_AVAILABLE = False
-from E5Gui.E5Action import E5Action
+from E5Gui.EricAction import EricAction
-from E5Gui import E5MessageBox, E5FileDialog, E5ErrorMessage
+from E5Gui import EricMessageBox, EricFileDialog, EricErrorMessage
-from E5Gui.E5MainWindow import E5MainWindow
+from E5Gui.EricMainWindow import EricMainWindow
-from E5Gui.E5Application import e5App
+from E5Gui.EricApplication import ericApp
-from E5Gui.E5ZoomWidget import E5ZoomWidget
+from E5Gui.EricZoomWidget import EricZoomWidget
-from E5Gui.E5OverrideCursor import E5OverrideCursor
+from E5Gui.EricOverrideCursor import EricOverrideCursor
 import Preferences
 from Preferences import Shortcuts
 import Utilities
 from .WebBrowserSingleApplication import WebBrowserSingleApplicationServer
 from eric7config import getConfig
-class WebBrowserWindow(E5MainWindow):
+class WebBrowserWindow(EricMainWindow):
 """
 Class implementing the web browser main window.
 @signal webBrowserWindowOpened(window) emitted after a new web browser
 window was opened
 @signal webBrowserOpened(browser) emitted after a new web browser tab was
 created
 @signal webBrowserClosed(browser) emitted after a web browser tab was
 closed
 """
-webBrowserWindowClosed = pyqtSignal(E5MainWindow)
+webBrowserWindowClosed = pyqtSignal(EricMainWindow)
-webBrowserWindowOpened = pyqtSignal(E5MainWindow)
+webBrowserWindowOpened = pyqtSignal(EricMainWindow)
 webBrowserOpened = pyqtSignal(QWidget)
 webBrowserClosed = pyqtSignal(QWidget)
 BrowserWindows = []
 self.__helpEngine.warning.connect(self.__warning)
 else:
 self.__helpEngine = None
 self.__helpInstaller = None
-self.__zoomWidget = E5ZoomWidget(
+self.__zoomWidget = EricZoomWidget(
 UI.PixmapCache.getPixmap("zoomOut"),
 UI.PixmapCache.getPixmap("zoomIn"),
 UI.PixmapCache.getPixmap("zoomReset"), self)
 self.statusBar().addPermanentWidget(self.__zoomWidget)
 self.__zoomWidget.setMapping(
 self.__virusTotal.urlScanReport.connect(
 self.__virusTotalUrlScanReport)
 self.__virusTotal.fileScanReport.connect(
 self.__virusTotalFileScanReport)
-e5App().focusChanged.connect(self.__appFocusChanged)
+ericApp().focusChanged.connect(self.__appFocusChanged)
 self.__toolbarStates = self.saveState()
 if single:
 self.SAServer = WebBrowserSingleApplicationServer(saname)
 Private method to define the user interface actions.
 """
 # list of all actions
 self.__actions = []
-self.newTabAct = E5Action(
+self.newTabAct = EricAction(
 self.tr('New Tab'),
 UI.PixmapCache.getIcon("tabNew"),
 self.tr('&New Tab'),
 QKeySequence(self.tr("Ctrl+T", "File|New Tab")),
 0, self, 'webbrowser_file_new_tab')
 """<p>This opens a new web browser tab.</p>"""
 ))
 self.newTabAct.triggered.connect(self.newTab)
 self.__actions.append(self.newTabAct)
-self.newAct = E5Action(
+self.newAct = EricAction(
 self.tr('New Window'),
 UI.PixmapCache.getIcon("newWindow"),
 self.tr('New &Window'),
 QKeySequence(self.tr("Ctrl+N", "File|New Window")),
 0, self, 'webbrowser_file_new_window')
 """ privacy mode.</p>"""
 ))
 self.newAct.triggered.connect(self.newWindow)
 self.__actions.append(self.newAct)
-self.newPrivateAct = E5Action(
+self.newPrivateAct = EricAction(
 self.tr('New Private Window'),
 UI.PixmapCache.getIcon("privateMode"),
 self.tr('New &Private Window'),
 QKeySequence(self.tr("Ctrl+Shift+P", "File|New Private Window")),
 0, self, 'webbrowser_file_new_private_window')
 """ a new web browser instance in private mode.</p>"""
 ))
 self.newPrivateAct.triggered.connect(self.newPrivateWindow)
 self.__actions.append(self.newPrivateAct)
-self.openAct = E5Action(
+self.openAct = EricAction(
 self.tr('Open File'),
 UI.PixmapCache.getIcon("open"),
 self.tr('&Open File'),
 QKeySequence(self.tr("Ctrl+O", "File|Open")),
 0, self, 'webbrowser_file_open')
 """ It pops up a file selection dialog.</p>"""
 ))
 self.openAct.triggered.connect(self.__openFile)
 self.__actions.append(self.openAct)
-self.openTabAct = E5Action(
+self.openTabAct = EricAction(
 self.tr('Open File in New Tab'),
 UI.PixmapCache.getIcon("openNewTab"),
 self.tr('Open File in New &Tab'),
 QKeySequence(self.tr("Shift+Ctrl+O", "File|Open in new tab")),
 0, self, 'webbrowser_file_open_tab')
 ))
 self.openTabAct.triggered.connect(self.__openFileNewTab)
 self.__actions.append(self.openTabAct)
 if hasattr(QWebEnginePage, "SavePage"):
-self.saveAsAct = E5Action(
+self.saveAsAct = EricAction(
 self.tr('Save As'),
 UI.PixmapCache.getIcon("fileSaveAs"),
 self.tr('&Save As...'),
 QKeySequence(self.tr("Shift+Ctrl+S", "File|Save As")),
 0, self, 'webbrowser_file_save_as')
 self.saveAsAct.triggered.connect(self.__savePageAs)
 self.__actions.append(self.saveAsAct)
 else:
 self.saveAsAct = None
-self.saveVisiblePageScreenAct = E5Action(
+self.saveVisiblePageScreenAct = EricAction(
 self.tr('Save Page Screen'),
 UI.PixmapCache.getIcon("fileSavePixmap"),
 self.tr('Save Page Screen...'),
 0, 0, self, 'webbrowser_file_save_visible_page_screen')
 self.saveVisiblePageScreenAct.setStatusTip(
 self.saveVisiblePageScreenAct.triggered.connect(
 self.__saveVisiblePageScreen)
 self.__actions.append(self.saveVisiblePageScreenAct)
 bookmarksManager = self.bookmarksManager()
-self.importBookmarksAct = E5Action(
+self.importBookmarksAct = EricAction(
 self.tr('Import Bookmarks'),
 self.tr('&Import Bookmarks...'),
 0, 0, self, 'webbrowser_file_import_bookmarks')
 self.importBookmarksAct.setStatusTip(
 self.tr('Import bookmarks from other browsers'))
 ))
 self.importBookmarksAct.triggered.connect(
 bookmarksManager.importBookmarks)
 self.__actions.append(self.importBookmarksAct)
-self.exportBookmarksAct = E5Action(
+self.exportBookmarksAct = EricAction(
 self.tr('Export Bookmarks'),
 self.tr('&Export Bookmarks...'),
 0, 0, self, 'webbrowser_file_export_bookmarks')
 self.exportBookmarksAct.setStatusTip(
 self.tr('Export the bookmarks into a file'))
 ))
 self.exportBookmarksAct.triggered.connect(
 bookmarksManager.exportBookmarks)
 self.__actions.append(self.exportBookmarksAct)
-self.printAct = E5Action(
+self.printAct = EricAction(
 self.tr('Print'),
 UI.PixmapCache.getIcon("print"),
 self.tr('&Print'),
 QKeySequence(self.tr("Ctrl+P", "File|Print")),
 0, self, 'webbrowser_file_print')
 """<p>Print the displayed help text.</p>"""
 ))
 self.printAct.triggered.connect(self.__tabWidget.printBrowser)
 self.__actions.append(self.printAct)
-self.printPdfAct = E5Action(
+self.printPdfAct = EricAction(
 self.tr('Print as PDF'),
 UI.PixmapCache.getIcon("printPdf"),
 self.tr('Print as PDF'),
 0, 0, self, 'webbrowser_file_print_pdf')
 self.printPdfAct.setStatusTip(self.tr(
 ))
 self.printPdfAct.triggered.connect(
 self.__tabWidget.printBrowserPdf)
 self.__actions.append(self.printPdfAct)
-self.printPreviewAct = E5Action(
+self.printPreviewAct = EricAction(
 self.tr('Print Preview'),
 UI.PixmapCache.getIcon("printPreview"),
 self.tr('Print Preview'),
 0, 0, self, 'webbrowser_file_print_preview')
 self.printPreviewAct.setStatusTip(self.tr(
 ))
 self.printPreviewAct.triggered.connect(
 self.__tabWidget.printPreviewBrowser)
 self.__actions.append(self.printPreviewAct)
-self.sendPageLinkAct = E5Action(
+self.sendPageLinkAct = EricAction(
 self.tr('Send Page Link'),
 UI.PixmapCache.getIcon("mailSend"),
 self.tr('Send Page Link'),
 0, 0, self, 'webbrowser_send_page_link')
 self.sendPageLinkAct.setStatusTip(self.tr(
 """<p>Send the link of the current page via email.</p>"""
 ))
 self.sendPageLinkAct.triggered.connect(self.__sendPageLink)
 self.__actions.append(self.sendPageLinkAct)
-self.closeAct = E5Action(
+self.closeAct = EricAction(
 self.tr('Close'),
 UI.PixmapCache.getIcon("close"),
 self.tr('&Close'),
 QKeySequence(self.tr("Ctrl+W", "File|Close")),
 0, self, 'webbrowser_file_close')
 """<p>Closes the current web browser window.</p>"""
 ))
 self.closeAct.triggered.connect(self.__tabWidget.closeBrowser)
 self.__actions.append(self.closeAct)
-self.closeAllAct = E5Action(
+self.closeAllAct = EricAction(
 self.tr('Close All'),
 self.tr('Close &All'),
 0, 0, self, 'webbrowser_file_close_all')
 self.closeAllAct.setStatusTip(self.tr('Close all help windows'))
 self.closeAllAct.setWhatsThis(self.tr(
 ))
 self.closeAllAct.triggered.connect(
 self.__tabWidget.closeAllBrowsers)
 self.__actions.append(self.closeAllAct)
-self.exitAct = E5Action(
+self.exitAct = EricAction(
 self.tr('Quit'),
 UI.PixmapCache.getIcon("exit"),
 self.tr('&Quit'),
 QKeySequence(self.tr("Ctrl+Q", "File|Quit")),
 0, self, 'webbrowser_file_quit')
 """<p>Quit the eric Web Browser.</p>"""
 ))
 self.exitAct.triggered.connect(self.shutdown)
 self.__actions.append(self.exitAct)
-self.backAct = E5Action(
+self.backAct = EricAction(
 self.tr('Backward'),
 UI.PixmapCache.getIcon("back"),
 self.tr('&Backward'),
 QKeySequence(self.tr("Alt+Left", "Go|Backward")),
 0, self, 'webbrowser_go_backward')
 """ available, this action is disabled.</p>"""
 ))
 self.backAct.triggered.connect(self.__backward)
 self.__actions.append(self.backAct)
-self.forwardAct = E5Action(
+self.forwardAct = EricAction(
 self.tr('Forward'),
 UI.PixmapCache.getIcon("forward"),
 self.tr('&Forward'),
 QKeySequence(self.tr("Alt+Right", "Go|Forward")),
 0, self, 'webbrowser_go_foreward')
 """ available, this action is disabled.</p>"""
 ))
 self.forwardAct.triggered.connect(self.__forward)
 self.__actions.append(self.forwardAct)
-self.homeAct = E5Action(
+self.homeAct = EricAction(
 self.tr('Home'),
 UI.PixmapCache.getIcon("home"),
 self.tr('&Home'),
 QKeySequence(self.tr("Ctrl+Home", "Go|Home")),
 0, self, 'webbrowser_go_home')
 """<p>Moves to the initial screen.</p>"""
 ))
 self.homeAct.triggered.connect(self.__home)
 self.__actions.append(self.homeAct)
-self.reloadAct = E5Action(
+self.reloadAct = EricAction(
 self.tr('Reload'),
 UI.PixmapCache.getIcon("reload"),
 self.tr('&Reload'),
 QKeySequence(self.tr("Ctrl+R", "Go|Reload")),
 QKeySequence(self.tr("F5", "Go|Reload")),
 """<p>Reloads the current screen.</p>"""
 ))
 self.reloadAct.triggered.connect(self.__reload)
 self.__actions.append(self.reloadAct)
-self.stopAct = E5Action(
+self.stopAct = EricAction(
 self.tr('Stop'),
 UI.PixmapCache.getIcon("stopLoading"),
 self.tr('&Stop'),
 QKeySequence(self.tr("Ctrl+.", "Go|Stop")),
 QKeySequence(self.tr("Esc", "Go|Stop")),
 """<p>Stops loading of the current tab.</p>"""
 ))
 self.stopAct.triggered.connect(self.__stopLoading)
 self.__actions.append(self.stopAct)
-self.copyAct = E5Action(
+self.copyAct = EricAction(
 self.tr('Copy'),
 UI.PixmapCache.getIcon("editCopy"),
 self.tr('&Copy'),
 QKeySequence(self.tr("Ctrl+C", "Edit|Copy")),
 0, self, 'webbrowser_edit_copy')
 """<p>Copy the selected text to the clipboard.</p>"""
 ))
 self.copyAct.triggered.connect(self.__copy)
 self.__actions.append(self.copyAct)
-self.cutAct = E5Action(
+self.cutAct = EricAction(
 self.tr('Cut'),
 UI.PixmapCache.getIcon("editCut"),
 self.tr('Cu&t'),
 QKeySequence(self.tr("Ctrl+X", "Edit|Cut")),
 0, self, 'webbrowser_edit_cut')
 """<p>Cut the selected text to the clipboard.</p>"""
 ))
 self.cutAct.triggered.connect(self.__cut)
 self.__actions.append(self.cutAct)
-self.pasteAct = E5Action(
+self.pasteAct = EricAction(
 self.tr('Paste'),
 UI.PixmapCache.getIcon("editPaste"),
 self.tr('&Paste'),
 QKeySequence(self.tr("Ctrl+V", "Edit|Paste")),
 0, self, 'webbrowser_edit_paste')
 """<p>Paste some text from the clipboard.</p>"""
 ))
 self.pasteAct.triggered.connect(self.__paste)
 self.__actions.append(self.pasteAct)
-self.undoAct = E5Action(
+self.undoAct = EricAction(
 self.tr('Undo'),
 UI.PixmapCache.getIcon("editUndo"),
 self.tr('&Undo'),
 QKeySequence(self.tr("Ctrl+Z", "Edit|Undo")),
 0, self, 'webbrowser_edit_undo')
 """<p>Undo the last edit action.</p>"""
 ))
 self.undoAct.triggered.connect(self.__undo)
 self.__actions.append(self.undoAct)
-self.redoAct = E5Action(
+self.redoAct = EricAction(
 self.tr('Redo'),
 UI.PixmapCache.getIcon("editRedo"),
 self.tr('&Redo'),
 QKeySequence(self.tr("Ctrl+Shift+Z", "Edit|Redo")),
 0, self, 'webbrowser_edit_redo')
 """<p>Redo the last edit action.</p>"""
 ))
 self.redoAct.triggered.connect(self.__redo)
 self.__actions.append(self.redoAct)
-self.selectAllAct = E5Action(
+self.selectAllAct = EricAction(
 self.tr('Select All'),
 UI.PixmapCache.getIcon("editSelectAll"),
 self.tr('&Select All'),
 QKeySequence(self.tr("Ctrl+A", "Edit|Select All")),
 0, self, 'webbrowser_edit_select_all')
 """<p>Select all text of the current browser.</p>"""
 ))
 self.selectAllAct.triggered.connect(self.__selectAll)
 self.__actions.append(self.selectAllAct)
-self.unselectAct = E5Action(
+self.unselectAct = EricAction(
 self.tr('Unselect'),
 self.tr('Unselect'),
 QKeySequence(self.tr("Alt+Ctrl+A", "Edit|Unselect")),
 0, self, 'webbrowser_edit_unselect')
 self.unselectAct.setStatusTip(self.tr('Clear current selection'))
 """<p>Clear the selection of the current browser.</p>"""
 ))
 self.unselectAct.triggered.connect(self.__unselect)
 self.__actions.append(self.unselectAct)
-self.findAct = E5Action(
+self.findAct = EricAction(
 self.tr('Find...'),
 UI.PixmapCache.getIcon("find"),
 self.tr('&Find...'),
 QKeySequence(self.tr("Ctrl+F", "Edit|Find")),
 0, self, 'webbrowser_edit_find')
 """<p>Find text in the current page.</p>"""
 ))
 self.findAct.triggered.connect(self.__find)
 self.__actions.append(self.findAct)
-self.findNextAct = E5Action(
+self.findNextAct = EricAction(
 self.tr('Find next'),
 UI.PixmapCache.getIcon("findNext"),
 self.tr('Find &next'),
 QKeySequence(self.tr("F3", "Edit|Find next")),
 0, self, 'webbrowser_edit_find_next')
 """<p>Find the next occurrence of text in the current page.</p>"""
 ))
 self.findNextAct.triggered.connect(self.__searchWidget.findNext)
 self.__actions.append(self.findNextAct)
-self.findPrevAct = E5Action(
+self.findPrevAct = EricAction(
 self.tr('Find previous'),
 UI.PixmapCache.getIcon("findPrev"),
 self.tr('Find &previous'),
 QKeySequence(self.tr("Shift+F3", "Edit|Find previous")),
 0, self, 'webbrowser_edit_find_previous')
 ))
 self.findPrevAct.triggered.connect(
 self.__searchWidget.findPrevious)
 self.__actions.append(self.findPrevAct)
-self.bookmarksManageAct = E5Action(
+self.bookmarksManageAct = EricAction(
 self.tr('Manage Bookmarks'),
 self.tr('&Manage Bookmarks...'),
 QKeySequence(self.tr("Ctrl+Shift+B", "Help|Manage bookmarks")),
 0, self, 'webbrowser_bookmarks_manage')
 self.bookmarksManageAct.setStatusTip(self.tr(
 ))
 self.bookmarksManageAct.triggered.connect(
 self.__showBookmarksDialog)
 self.__actions.append(self.bookmarksManageAct)
-self.bookmarksAddAct = E5Action(
+self.bookmarksAddAct = EricAction(
 self.tr('Add Bookmark'),
 UI.PixmapCache.getIcon("addBookmark"),
 self.tr('Add &Bookmark...'),
 QKeySequence(self.tr("Ctrl+D", "Help|Add bookmark")),
 0, self, 'webbrowser_bookmark_add')
 """<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.bookmarksAddFolderAct = EricAction(
 self.tr('Add Folder'),
 self.tr('Add &Folder...'),
 0, 0, self, 'webbrowser_bookmark_show_all')
 self.bookmarksAddFolderAct.setStatusTip(self.tr(
 'Open a dialog to add a new bookmarks folder.'))
 ))
 self.bookmarksAddFolderAct.triggered.connect(
 self.__addBookmarkFolder)
 self.__actions.append(self.bookmarksAddFolderAct)
-self.bookmarksAllTabsAct = E5Action(
+self.bookmarksAllTabsAct = EricAction(
 self.tr('Bookmark All Tabs'),
 self.tr('Bookmark All Tabs...'),
 0, 0, self, 'webbrowser_bookmark_all_tabs')
 self.bookmarksAllTabsAct.setStatusTip(self.tr(
 'Bookmark all open tabs.'))
 """ all open tabs.</p>"""
 ))
 self.bookmarksAllTabsAct.triggered.connect(self.bookmarkAll)
 self.__actions.append(self.bookmarksAllTabsAct)
-self.whatsThisAct = E5Action(
+self.whatsThisAct = EricAction(
 self.tr('What\'s This?'),
 UI.PixmapCache.getIcon("whatsThis"),
 self.tr('&What\'s This?'),
 QKeySequence(self.tr("Shift+F1", "Help|What's This?'")),
 0, self, 'webbrowser_help_whats_this')
 """ the context help button in the titlebar.</p>"""
 ))
 self.whatsThisAct.triggered.connect(self.__whatsThis)
 self.__actions.append(self.whatsThisAct)
-self.aboutAct = E5Action(
+self.aboutAct = EricAction(
 self.tr('About'),
 self.tr('&About'),
 0, 0, self, 'webbrowser_help_about')
 self.aboutAct.setStatusTip(self.tr(
 'Display information about this software'))
 """<p>Display some information about this software.</p>"""
 ))
 self.aboutAct.triggered.connect(self.__about)
 self.__actions.append(self.aboutAct)
-self.aboutQtAct = E5Action(
+self.aboutQtAct = EricAction(
 self.tr('About Qt'),
 self.tr('About &Qt'),
 0, 0, self, 'webbrowser_help_about_qt')
 self.aboutQtAct.setStatusTip(
 self.tr('Display information about the Qt toolkit'))
 """<p>Display some information about the Qt toolkit.</p>"""
 ))
 self.aboutQtAct.triggered.connect(self.__aboutQt)
 self.__actions.append(self.aboutQtAct)
-self.zoomInAct = E5Action(
+self.zoomInAct = EricAction(
 self.tr('Zoom in'),
 UI.PixmapCache.getIcon("zoomIn"),
 self.tr('Zoom &in'),
 QKeySequence(self.tr("Ctrl++", "View|Zoom in")),
 QKeySequence(self.tr("Zoom In", "View|Zoom in")),
 """ This makes the web page bigger.</p>"""
 ))
 self.zoomInAct.triggered.connect(self.__zoomIn)
 self.__actions.append(self.zoomInAct)
-self.zoomOutAct = E5Action(
+self.zoomOutAct = EricAction(
 self.tr('Zoom out'),
 UI.PixmapCache.getIcon("zoomOut"),
 self.tr('Zoom &out'),
 QKeySequence(self.tr("Ctrl+-", "View|Zoom out")),
 QKeySequence(self.tr("Zoom Out", "View|Zoom out")),
 """ This makes the web page smaller.</p>"""
 ))
 self.zoomOutAct.triggered.connect(self.__zoomOut)
 self.__actions.append(self.zoomOutAct)
-self.zoomResetAct = E5Action(
+self.zoomResetAct = EricAction(
 self.tr('Zoom reset'),
 UI.PixmapCache.getIcon("zoomReset"),
 self.tr('Zoom &reset'),
 QKeySequence(self.tr("Ctrl+0", "View|Zoom reset")),
 0, self, 'webbrowser_view_zoom_reset')
 """This sets the zoom factor to 100%.</p>"""
 ))
 self.zoomResetAct.triggered.connect(self.__zoomReset)
 self.__actions.append(self.zoomResetAct)
-self.pageSourceAct = E5Action(
+self.pageSourceAct = EricAction(
 self.tr('Show page source'),
 self.tr('Show page source'),
 QKeySequence(self.tr('Ctrl+U')), 0,
 self, 'webbrowser_show_page_source')
 self.pageSourceAct.setStatusTip(self.tr(
 ))
 self.pageSourceAct.triggered.connect(self.__showPageSource)
 self.__actions.append(self.pageSourceAct)
 self.addAction(self.pageSourceAct)
-self.fullScreenAct = E5Action(
+self.fullScreenAct = EricAction(
 self.tr('Full Screen'),
 UI.PixmapCache.getIcon("windowFullscreen"),
 self.tr('&Full Screen'),
 0, 0,
 self, 'webbrowser_view_full_screen')
 self.fullScreenAct.setShortcut(QKeySequence(self.tr('F11')))
 self.fullScreenAct.triggered.connect(self.toggleFullScreen)
 self.__actions.append(self.fullScreenAct)
 self.addAction(self.fullScreenAct)
-self.nextTabAct = E5Action(
+self.nextTabAct = EricAction(
 self.tr('Show next tab'),
 self.tr('Show next tab'),
 QKeySequence(self.tr('Ctrl+Alt+Tab')), 0,
 self, 'webbrowser_view_next_tab')
 self.nextTabAct.triggered.connect(self.__nextTab)
 self.__actions.append(self.nextTabAct)
 self.addAction(self.nextTabAct)
-self.prevTabAct = E5Action(
+self.prevTabAct = EricAction(
 self.tr('Show previous tab'),
 self.tr('Show previous tab'),
 QKeySequence(self.tr('Shift+Ctrl+Alt+Tab')), 0,
 self, 'webbrowser_view_previous_tab')
 self.prevTabAct.triggered.connect(self.__prevTab)
 self.__actions.append(self.prevTabAct)
 self.addAction(self.prevTabAct)
-self.switchTabAct = E5Action(
+self.switchTabAct = EricAction(
 self.tr('Switch between tabs'),
 self.tr('Switch between tabs'),
 QKeySequence(self.tr('Ctrl+1')), 0,
 self, 'webbrowser_switch_tabs')
 self.switchTabAct.triggered.connect(self.__switchTab)
 self.__actions.append(self.switchTabAct)
 self.addAction(self.switchTabAct)
-self.prefAct = E5Action(
+self.prefAct = EricAction(
 self.tr('Preferences'),
 UI.PixmapCache.getIcon("configure"),
 self.tr('&Preferences...'), 0, 0, self, 'webbrowser_preferences')
 self.prefAct.setStatusTip(self.tr(
 'Set the prefered configuration'))
 """ with your prefered values.</p>"""
 ))
 self.prefAct.triggered.connect(self.__showPreferences)
 self.__actions.append(self.prefAct)
-self.acceptedLanguagesAct = E5Action(
+self.acceptedLanguagesAct = EricAction(
 self.tr('Languages'),
 UI.PixmapCache.getIcon("flag"),
 self.tr('&Languages...'), 0, 0,
 self, 'webbrowser_accepted_languages')
 self.acceptedLanguagesAct.setStatusTip(self.tr(
 ))
 self.acceptedLanguagesAct.triggered.connect(
 self.__showAcceptedLanguages)
 self.__actions.append(self.acceptedLanguagesAct)
-self.cookiesAct = E5Action(
+self.cookiesAct = EricAction(
 self.tr('Cookies'),
 UI.PixmapCache.getIcon("cookie"),
 self.tr('C&ookies...'), 0, 0, self, 'webbrowser_cookies')
 self.cookiesAct.setStatusTip(self.tr(
 'Configure cookies handling'))
 ))
 self.cookiesAct.triggered.connect(
 self.__showCookiesConfiguration)
 self.__actions.append(self.cookiesAct)
-self.personalDataAct = E5Action(
+self.personalDataAct = EricAction(
 self.tr('Personal Information'),
 UI.PixmapCache.getIcon("pim"),
 self.tr('Personal Information...'),
 0, 0,
 self, 'webbrowser_personal_information')
 ))
 self.personalDataAct.triggered.connect(
 self.__showPersonalInformationDialog)
 self.__actions.append(self.personalDataAct)
-self.greaseMonkeyAct = E5Action(
+self.greaseMonkeyAct = EricAction(
 self.tr('GreaseMonkey Scripts'),
 UI.PixmapCache.getIcon("greaseMonkey"),
 self.tr('GreaseMonkey Scripts...'),
 0, 0,
 self, 'webbrowser_greasemonkey')
 ))
 self.greaseMonkeyAct.triggered.connect(
 self.__showGreaseMonkeyConfigDialog)
 self.__actions.append(self.greaseMonkeyAct)
-self.editMessageFilterAct = E5Action(
+self.editMessageFilterAct = EricAction(
 self.tr('Edit Message Filters'),
 UI.PixmapCache.getIcon("warning"),
 self.tr('Edit Message Filters...'), 0, 0, self,
 'webbrowser_manage_message_filters')
 self.editMessageFilterAct.setStatusTip(self.tr(
 """<p>Opens a dialog to edit the message filters used to"""
 """ suppress unwanted messages been shown in an error"""
 """ window.</p>"""
 ))
 self.editMessageFilterAct.triggered.connect(
-E5ErrorMessage.editMessageFilters)
+EricErrorMessage.editMessageFilters)
 self.__actions.append(self.editMessageFilterAct)
-self.featurePermissionAct = E5Action(
+self.featurePermissionAct = EricAction(
 self.tr('Edit HTML5 Feature Permissions'),
 UI.PixmapCache.getIcon("featurePermission"),
 self.tr('Edit HTML5 Feature Permissions...'), 0, 0, self,
 'webbrowser_edit_feature_permissions')
 self.featurePermissionAct.setStatusTip(self.tr(
 self.featurePermissionAct.triggered.connect(
 self.__showFeaturePermissionDialog)
 self.__actions.append(self.featurePermissionAct)
 if WebBrowserWindow._useQtHelp:
-self.syncTocAct = E5Action(
+self.syncTocAct = EricAction(
 self.tr('Sync with Table of Contents'),
 UI.PixmapCache.getIcon("syncToc"),
 self.tr('Sync with Table of Contents'),
 0, 0, self, 'webbrowser_sync_toc')
 self.syncTocAct.setStatusTip(self.tr(
 """ page.</p>"""
 ))
 self.syncTocAct.triggered.connect(self.__syncTOC)
 self.__actions.append(self.syncTocAct)
-self.showTocAct = E5Action(
+self.showTocAct = EricAction(
 self.tr('Table of Contents'),
 self.tr('Table of Contents'),
 0, 0, self, 'webbrowser_show_toc')
 self.showTocAct.setStatusTip(self.tr(
 'Shows the table of contents window'))
 """<p>Shows the table of contents window.</p>"""
 ))
 self.showTocAct.triggered.connect(self.__showTocWindow)
 self.__actions.append(self.showTocAct)
-self.showIndexAct = E5Action(
+self.showIndexAct = EricAction(
 self.tr('Index'),
 self.tr('Index'),
 0, 0, self, 'webbrowser_show_index')
 self.showIndexAct.setStatusTip(self.tr(
 'Shows the index window'))
 """<p>Shows the index window.</p>"""
 ))
 self.showIndexAct.triggered.connect(self.__showIndexWindow)
 self.__actions.append(self.showIndexAct)
-self.showSearchAct = E5Action(
+self.showSearchAct = EricAction(
 self.tr('Search'),
 self.tr('Search'),
 0, 0, self, 'webbrowser_show_search')
 self.showSearchAct.setStatusTip(self.tr(
 'Shows the search window'))
 ))
 self.showSearchAct.triggered.connect(
 self.__showSearchWindow)
 self.__actions.append(self.showSearchAct)
-self.manageQtHelpDocsAct = E5Action(
+self.manageQtHelpDocsAct = EricAction(
 self.tr('Manage QtHelp Documents'),
 self.tr('Manage QtHelp &Documents'),
 0, 0, self, 'webbrowser_qthelp_documents')
 self.manageQtHelpDocsAct.setStatusTip(self.tr(
 'Shows a dialog to manage the QtHelp documentation set'))
 ))
 self.manageQtHelpDocsAct.triggered.connect(
 self.__manageQtHelpDocumentation)
 self.__actions.append(self.manageQtHelpDocsAct)
-self.reindexDocumentationAct = E5Action(
+self.reindexDocumentationAct = EricAction(
 self.tr('Reindex Documentation'),
 self.tr('&Reindex Documentation'),
 0, 0, self, 'webbrowser_qthelp_reindex')
 self.reindexDocumentationAct.setStatusTip(self.tr(
 'Reindexes the documentation set'))
 ))
 self.reindexDocumentationAct.triggered.connect(
 self.__searchEngine.reindexDocumentation)
 self.__actions.append(self.reindexDocumentationAct)
-self.clearPrivateDataAct = E5Action(
+self.clearPrivateDataAct = EricAction(
 self.tr('Clear private data'),
 UI.PixmapCache.getIcon("clearPrivateData"),
 self.tr('Clear private data'),
 0, 0,
 self, 'webbrowser_clear_private_data')
 ))
 self.clearPrivateDataAct.triggered.connect(
 self.__clearPrivateData)
 self.__actions.append(self.clearPrivateDataAct)
-self.clearIconsAct = E5Action(
+self.clearIconsAct = EricAction(
 self.tr('Clear icons database'),
 self.tr('Clear &icons database'),
 0, 0,
 self, 'webbrowser_clear_icons_db')
 self.clearIconsAct.setStatusTip(self.tr(
 """ URLs.</p>"""
 ))
 self.clearIconsAct.triggered.connect(self.__clearIconsDatabase)
 self.__actions.append(self.clearIconsAct)
-self.manageIconsAct = E5Action(
+self.manageIconsAct = EricAction(
 self.tr('Manage saved Favicons'),
 UI.PixmapCache.getIcon("icons"),
 self.tr('Manage saved Favicons'),
 0, 0,
 self, 'webbrowser_manage_icons_db')
 """ previously visited URLs.</p>"""
 ))
 self.manageIconsAct.triggered.connect(self.__showWebIconsDialog)
 self.__actions.append(self.manageIconsAct)
-self.searchEnginesAct = E5Action(
+self.searchEnginesAct = EricAction(
 self.tr('Configure Search Engines'),
 self.tr('Configure Search &Engines...'),
 0, 0,
 self, 'webbrowser_search_engines')
 self.searchEnginesAct.setStatusTip(self.tr(
 ))
 self.searchEnginesAct.triggered.connect(
 self.__showEnginesConfigurationDialog)
 self.__actions.append(self.searchEnginesAct)
-self.passwordsAct = E5Action(
+self.passwordsAct = EricAction(
 self.tr('Manage Saved Passwords'),
 UI.PixmapCache.getIcon("passwords"),
 self.tr('Manage Saved Passwords...'),
 0, 0,
 self, 'webbrowser_manage_passwords')
 """<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.adblockAct = EricAction(
 self.tr('Ad Block'),
 UI.PixmapCache.getIcon("adBlockPlus"),
 self.tr('&Ad Block...'),
 0, 0,
 self, 'webbrowser_adblock')
 """ rules.</p>"""
 ))
 self.adblockAct.triggered.connect(self.__showAdBlockDialog)
 self.__actions.append(self.adblockAct)
-self.certificateErrorsAct = E5Action(
+self.certificateErrorsAct = EricAction(
 self.tr('Manage SSL Certificate Errors'),
 UI.PixmapCache.getIcon("certificates"),
 self.tr('Manage SSL Certificate Errors...'),
 0, 0,
 self, 'webbrowser_manage_certificate_errors')
 ))
 self.certificateErrorsAct.triggered.connect(
 self.__showCertificateErrorsDialog)
 self.__actions.append(self.certificateErrorsAct)
-self.safeBrowsingAct = E5Action(
+self.safeBrowsingAct = EricAction(
 self.tr('Manage Safe Browsing'),
 UI.PixmapCache.getIcon("safeBrowsing"),
 self.tr('Manage Safe Browsing...'), 0, 0, self,
 'webbrowser_manage_safe_browsing')
 self.safeBrowsingAct.setStatusTip(self.tr(
 ))
 self.safeBrowsingAct.triggered.connect(
 self.__showSafeBrowsingDialog)
 self.__actions.append(self.safeBrowsingAct)
-self.showDownloadManagerAct = E5Action(
+self.showDownloadManagerAct = EricAction(
 self.tr('Downloads'),
 self.tr('Downloads'),
 0, 0, self, 'webbrowser_show_downloads')
 self.showDownloadManagerAct.setStatusTip(self.tr(
 'Shows the downloads window'))
 ))
 self.showDownloadManagerAct.triggered.connect(
 self.__showDownloadsWindow)
 self.__actions.append(self.showDownloadManagerAct)
-self.feedsManagerAct = E5Action(
+self.feedsManagerAct = EricAction(
 self.tr('RSS Feeds Dialog'),
 UI.PixmapCache.getIcon("rss22"),
 self.tr('&RSS Feeds Dialog...'),
 QKeySequence(self.tr("Ctrl+Shift+F", "Help|RSS Feeds Dialog")),
 0, self, 'webbrowser_rss_feeds')
 """ contents.</p>"""
 ))
 self.feedsManagerAct.triggered.connect(self.__showFeedsManager)
 self.__actions.append(self.feedsManagerAct)
-self.siteInfoAct = E5Action(
+self.siteInfoAct = EricAction(
 self.tr('Siteinfo Dialog'),
 UI.PixmapCache.getIcon("helpAbout"),
 self.tr('&Siteinfo Dialog...'),
 QKeySequence(self.tr("Ctrl+Shift+I", "Help|Siteinfo Dialog")),
 0, self, 'webbrowser_siteinfo')
 """ site.</p>"""
 ))
 self.siteInfoAct.triggered.connect(self.__showSiteinfoDialog)
 self.__actions.append(self.siteInfoAct)
-self.userAgentManagerAct = E5Action(
+self.userAgentManagerAct = EricAction(
 self.tr('Manage User Agent Settings'),
 self.tr('Manage &User Agent Settings'),
 0, 0, self, 'webbrowser_user_agent_settings')
 self.userAgentManagerAct.setStatusTip(self.tr(
 'Shows a dialog to manage the User Agent settings'))
 ))
 self.userAgentManagerAct.triggered.connect(
 self.__showUserAgentsDialog)
 self.__actions.append(self.userAgentManagerAct)
-self.synchronizationAct = E5Action(
+self.synchronizationAct = EricAction(
 self.tr('Synchronize data'),
 UI.PixmapCache.getIcon("sync"),
 self.tr('&Synchronize Data...'),
 0, 0, self, 'webbrowser_synchronize_data')
 self.synchronizationAct.setStatusTip(self.tr(
 ))
 self.synchronizationAct.triggered.connect(
 self.__showSyncDialog)
 self.__actions.append(self.synchronizationAct)
-self.zoomValuesAct = E5Action(
+self.zoomValuesAct = EricAction(
 self.tr('Manage Saved Zoom Values'),
 UI.PixmapCache.getIcon("zoomReset"),
 self.tr('Manage Saved Zoom Values...'),
 0, 0,
 self, 'webbrowser_manage_zoom_values')
 """<p>Opens a dialog to manage the saved zoom values.</p>"""
 ))
 self.zoomValuesAct.triggered.connect(self.__showZoomValuesDialog)
 self.__actions.append(self.zoomValuesAct)
-self.showJavaScriptConsoleAct = E5Action(
+self.showJavaScriptConsoleAct = EricAction(
 self.tr('JavaScript Console'),
 self.tr('JavaScript Console'),
 0, 0, self, 'webbrowser_show_javascript_console')
 self.showJavaScriptConsoleAct.setStatusTip(self.tr(
 'Toggle the JavaScript console window'))
 ))
 self.showJavaScriptConsoleAct.triggered.connect(
 self.__toggleJavaScriptConsole)
 self.__actions.append(self.showJavaScriptConsoleAct)
-self.showTabManagerAct = E5Action(
+self.showTabManagerAct = EricAction(
 self.tr('Tab Manager'),
 self.tr('Tab Manager'),
 0, 0, self, 'webbrowser_show_tab_manager')
 self.showTabManagerAct.setStatusTip(self.tr(
 'Shows the tab manager window'))
 ))
 self.showTabManagerAct.triggered.connect(
 lambda: self.__showTabManager(self.showTabManagerAct))
 self.__actions.append(self.showTabManagerAct)
-self.showSessionsManagerAct = E5Action(
+self.showSessionsManagerAct = EricAction(
 self.tr('Session Manager'),
 self.tr('Session Manager...'),
 0, 0, self, 'webbrowser_show_session_manager')
 self.showSessionsManagerAct.setStatusTip(self.tr(
 'Shows the session manager window'))
 ))
 self.showSessionsManagerAct.triggered.connect(
 self.__showSessionManagerDialog)
 self.__actions.append(self.showSessionsManagerAct)
-self.virustotalScanCurrentAct = E5Action(
+self.virustotalScanCurrentAct = EricAction(
 self.tr("Scan current site"),
 UI.PixmapCache.getIcon("virustotal"),
 self.tr("Scan current site"),
 0, 0,
 self, 'webbrowser_virustotal_scan_site')
 self.virustotalScanCurrentAct.triggered.connect(
 self.__virusTotalScanCurrentSite)
 self.__actions.append(self.virustotalScanCurrentAct)
-self.virustotalIpReportAct = E5Action(
+self.virustotalIpReportAct = EricAction(
 self.tr("IP Address Report"),
 UI.PixmapCache.getIcon("virustotal"),
 self.tr("IP Address Report"),
 0, 0,
 self, 'webbrowser_virustotal_ip_report')
 self.virustotalIpReportAct.triggered.connect(
 self.__virusTotalIpAddressReport)
 self.__actions.append(self.virustotalIpReportAct)
-self.virustotalDomainReportAct = E5Action(
+self.virustotalDomainReportAct = EricAction(
 self.tr("Domain Report"),
 UI.PixmapCache.getIcon("virustotal"),
 self.tr("Domain Report"),
 0, 0,
 self, 'webbrowser_virustotal_domain_report')
 ):
 self.virustotalScanCurrentAct.setEnabled(False)
 self.virustotalIpReportAct.setEnabled(False)
 self.virustotalDomainReportAct.setEnabled(False)
-self.shortcutsAct = E5Action(
+self.shortcutsAct = EricAction(
 self.tr('Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("configureShortcuts"),
 self.tr('Keyboard &Shortcuts...'),
 0, 0,
 self, 'webbrowser_keyboard_shortcuts')
 """ with your prefered values.</p>"""
 ))
 self.shortcutsAct.triggered.connect(self.__configShortcuts)
 self.__actions.append(self.shortcutsAct)
-self.exportShortcutsAct = E5Action(
+self.exportShortcutsAct = EricAction(
 self.tr('Export Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("exportShortcuts"),
 self.tr('&Export Keyboard Shortcuts...'),
 0, 0, self, 'export_keyboard_shortcuts')
 self.exportShortcutsAct.setStatusTip(self.tr(
 """<p>Export the keyboard shortcuts of the application.</p>"""
 ))
 self.exportShortcutsAct.triggered.connect(self.__exportShortcuts)
 self.__actions.append(self.exportShortcutsAct)
-self.importShortcutsAct = E5Action(
+self.importShortcutsAct = EricAction(
 self.tr('Import Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("importShortcuts"),
 self.tr('&Import Keyboard Shortcuts...'),
 0, 0, self, 'import_keyboard_shortcuts')
 self.importShortcutsAct.setStatusTip(self.tr(
 """<p>Import the keyboard shortcuts of the application.</p>"""
 ))
 self.importShortcutsAct.triggered.connect(self.__importShortcuts)
 self.__actions.append(self.importShortcutsAct)
-self.showProtocolHandlerManagerAct = E5Action(
+self.showProtocolHandlerManagerAct = EricAction(
 self.tr('Protocol Handler Manager'),
 self.tr('Protocol Handler Manager...'),
 0, 0, self, 'webbrowser_show_protocol_handler_manager')
 self.showProtocolHandlerManagerAct.setStatusTip(self.tr(
 'Shows the protocol handler manager window'))
 def getActions(self):
 """
 Public method to get a list of all actions.
-@return list of all actions (list of E5Action)
+@return list of all actions (list of EricAction)
 """
 return self.__actions[:]
 def getActionsCategory(self):
 """
 if (
 not os.path.isfile(applPath) or
 not QProcess.startDetached(sys.executable, args)
 ):
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr('New Private Window'),
 self.tr(
 '<p>Could not start the process.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 def __openFile(self):
 """
 Private slot called to open a file.
 """
-fn = E5FileDialog.getOpenFileName(
+fn = EricFileDialog.getOpenFileName(
 self,
 self.tr("Open File"),
 "",
 self.tr("HTML Files (*.html *.htm *.mhtml *.mht);;"
 "PDF Files (*.pdf);;"
 def __openFileNewTab(self):
 """
 Private slot called to open a file in a new tab.
 """
-fn = E5FileDialog.getOpenFileName(
+fn = EricFileDialog.getOpenFileName(
 self,
 self.tr("Open File"),
 "",
 self.tr("HTML Files (*.html *.htm *.mhtml *.mht);;"
 "PDF Files (*.pdf);;"
 Private slot to show the about information.
 """
 chromeVersion, webengineVersion = (
 WebBrowserTools.getWebEngineVersions()
 )
-E5MessageBox.about(
+EricMessageBox.about(
 self,
 self.tr("eric Web Browser"),
 self.tr(
 """<b>eric Web Browser - {0}</b>"""
 """<p>The eric Web Browser is a combined help file and HTML"""
 def __aboutQt(self):
 """
 Private slot to show info about Qt.
 """
-E5MessageBox.aboutQt(self, self.tr("eric Web Browser"))
+EricMessageBox.aboutQt(self, self.tr("eric Web Browser"))
 def setBackwardAvailable(self, b):
 """
 Public slot called when backward references are available.
 tabCount = 0
 for browser in WebBrowserWindow.BrowserWindows:
 tabCount += browser.tabWidget().count()
 if windowCount > 1 or tabCount > 1:
-mb = E5MessageBox.E5MessageBox(
+mb = EricMessageBox.EricMessageBox(
-E5MessageBox.Information,
+EricMessageBox.Information,
 self.tr("Are you sure you want to close the web browser?"),
 self.tr("""Are you sure you want to close the web"""
 """ browser?\n"""
 """You have {0} windows with {1} tabs open.""")
 .format(windowCount, tabCount),
 modal=True,
 parent=self)
 quitButton = mb.addButton(
-self.tr("&Quit"), E5MessageBox.AcceptRole)
+self.tr("&Quit"), EricMessageBox.AcceptRole)
 quitButton.setIcon(UI.PixmapCache.getIcon("exit"))
-mb.addButton(E5MessageBox.Cancel)
+mb.addButton(EricMessageBox.Cancel)
 mb.exec()
 return mb.clickedButton() == quitButton
 return True
 def __syncTOC(self):
 """
 Private slot to synchronize the TOC with the currently shown page.
 """
 if WebBrowserWindow._useQtHelp:
-with E5OverrideCursor():
+with EricOverrideCursor():
 url = self.currentBrowser().source()
 self.__showTocWindow()
 if not self.__tocWindow.syncToContent(url):
 self.statusBar().showMessage(
 self.tr("Could not find an associated content."), 5000)
 """
 Private slot to show installation errors.
 @param message message to be shown (string)
 """
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("eric Web Browser"),
 message)
 def __docsInstalled(self, installed):
 """
 Private slot handling warnings from the help engine.
 @param msg message sent by the help  engine (string)
 """
-E5MessageBox.warning(
+EricMessageBox.warning(
 self,
 self.tr("Help Engine"), msg)
 def __aboutToShowSettingsMenu(self):
 """
 Private slot to show the Settings menu.
 """
 self.editMessageFilterAct.setEnabled(
-E5ErrorMessage.messageHandlerInstalled())
+EricErrorMessage.messageHandlerInstalled())
 def __clearPrivateData(self):
 """
 Private slot to clear the private data.
 """
 @pyqtSlot()
 def __appFocusChanged(self):
 """
 Private slot to handle a change of the focus.
 """
-focusWindow = e5App().activeWindow()
+focusWindow = ericApp().activeWindow()
 if isinstance(focusWindow, WebBrowserWindow):
 WebBrowserWindow._lastActiveWindow = focusWindow
 @classmethod
 def getWindow(cls):
 """
 Private slot to handle an URL scan submission error.
 @param msg error message (str)
 """
-E5MessageBox.critical(
+EricMessageBox.critical(
 self,
 self.tr("VirusTotal Scan"),
 self.tr("""<p>The VirusTotal scan could not be"""
 """ scheduled.<p>\n<p>Reason: {0}</p>""").format(msg))
 QLineEdit.EchoMode.Normal)
 if ok and ip:
 if ip.count(".") == 3:
 self.__virusTotal.getIpAddressReport(ip)
 else:
-E5MessageBox.information(
+EricMessageBox.information(
 self,
 self.tr("IP Address Report"),
 self.tr("""The given IP address is not in dotted quad"""
 """ notation."""))
 def __exportShortcuts(self):
 """
 Private slot to export the keyboard shortcuts.
 """
-fn, selectedFilter = E5FileDialog.getSaveFileNameAndFilter(
+fn, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
 None,
 self.tr("Export Keyboard Shortcuts"),
 "",
 self.tr("Keyboard Shortcuts File (*.ekj)"),
 "",
-E5FileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite)
 if not fn:
 return
 ext = QFileInfo(fn).suffix()
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fn += ex
 ok = (
-E5MessageBox.yesNo(
+EricMessageBox.yesNo(
 self,
 self.tr("Export Keyboard Shortcuts"),
 self.tr("""<p>The keyboard shortcuts file <b>{0}</b> exists"""
 """ already. Overwrite it?</p>""").format(fn))
 if os.path.exists(fn) else
 def __importShortcuts(self):
 """
 Private slot to import the keyboard shortcuts.
 """
-fn = E5FileDialog.getOpenFileName(
+fn = EricFileDialog.getOpenFileName(
 None,
 self.tr("Import Keyboard Shortcuts"),
 "",
 self.tr("Keyboard Shortcuts File (*.ekj);;"
 "XML Keyboard shortcut file (*.e4k)"))

Mercurial Repositories > eric / file comparison

comparison: eric7/WebBrowser/WebBrowserWindow.py

eric7/WebBrowser/WebBrowserWindow.py