eric: comparison src/eric7/WebBrowser/WebBrowserWindow.py

-:0b936ff1bbb9
+:a2bc06a54d9d
 from eric7 import Globals, Preferences, Utilities
 from eric7.EricGui import EricPixmapCache
 from eric7.EricGui.EricAction import EricAction
 from eric7.EricGui.EricOverrideCursor import EricOverrideCursor
 from eric7.EricNetwork.EricNetworkIcon import EricNetworkIcon
+from eric7.EricNetwork.EricSslUtilities import initSSL
 from eric7.EricWidgets import EricErrorMessage, EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.EricWidgets.EricMainWindow import EricMainWindow
 from eric7.EricWidgets.EricZoomWidget import EricZoomWidget
 from eric7.Globals import getConfig
 from eric7.Preferences import Shortcuts
+from eric7.Preferences.ShortcutsDialog import ShortcutsDialog
 from eric7.UI import Config
 from eric7.UI.Info import Version
 from eric7.UI.NotificationWidget import NotificationTypes
 from eric7.WebBrowser.Tools import WebIconProvider
 from eric7.WebBrowser.ZoomManager import ZoomManager
 @param single flag indicating to start in single application mode
 @type bool
 @param saname name to be used for the single application server
 @type str
 """
-self.__hideNavigationTimer = None
-super().__init__(parent)
-self.setObjectName(name)
-if private:
-self.setWindowTitle(self.tr("eric Web Browser (Private Mode)"))
-else:
-self.setWindowTitle(self.tr("eric Web Browser"))
-self.__settingsDir = settingsDir
-self.setWindowIcon(EricPixmapCache.getIcon("ericWeb"))
-self.__mHistory = []
-self.__lastConfigurationPageName = ""
-WebBrowserWindow._isPrivate = private
-self.__shortcutsDialog = None
-WebBrowserWindow.setUseQtHelp(qthelp or bool(searchWord))
-self.webProfile(private)
-self.networkManager()
-self.__htmlFullScreen = False
-self.__windowStates = Qt.WindowState.WindowNoState
-self.__isClosing = False
 from .AdBlock.AdBlockIcon import AdBlockIcon
 from .Bookmarks.BookmarksToolBar import BookmarksToolBar
 from .Navigation.NavigationBar import NavigationBar
 from .Navigation.NavigationContainer import NavigationContainer
 from .QtHelp.HelpIndexWidget import HelpIndexWidget
 from .QtHelp.HelpTocWidget import HelpTocWidget
 from .SearchWidget import SearchWidget
 from .StatusBar.ImagesIcon import ImagesIcon
 from .StatusBar.JavaScriptIcon import JavaScriptIcon
 from .VirusTotal.VirusTotalApi import VirusTotalAPI
+from .WebBrowserJavaScriptConsole import WebBrowserJavaScriptConsole
 from .WebBrowserTabWidget import WebBrowserTabWidget
 from .WebBrowserView import WebBrowserView
+self.__hideNavigationTimer = None
+super().__init__(parent)
+self.setObjectName(name)
+if private:
+self.setWindowTitle(self.tr("eric Web Browser (Private Mode)"))
+else:
+self.setWindowTitle(self.tr("eric Web Browser"))
+self.__settingsDir = settingsDir
+self.setWindowIcon(EricPixmapCache.getIcon("ericWeb"))
+self.__mHistory = []
+self.__lastConfigurationPageName = ""
+WebBrowserWindow._isPrivate = private
+self.__shortcutsDialog = None
+WebBrowserWindow.setUseQtHelp(qthelp or bool(searchWord))
+self.webProfile(private)
+self.networkManager()
+self.__htmlFullScreen = False
+self.__windowStates = Qt.WindowState.WindowNoState
+self.__isClosing = False
 self.setStyle(Preferences.getUI("Style"), Preferences.getUI("StyleSheet"))
 # initialize some SSL stuff
-from eric7.EricNetwork.EricSslUtilities import initSSL
 initSSL()
 if WebBrowserWindow._useQtHelp:
 self.__helpEngine = QHelpEngine(
 WebBrowserWindow.getQtHelpCollectionFileName(), self
 self.__searchDock.setObjectName("SearchWindow")
 self.__searchDock.setWidget(self.__searchWindow)
 self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, self.__searchDock)
 # JavaScript Console window
-from .WebBrowserJavaScriptConsole import WebBrowserJavaScriptConsole
 self.__javascriptConsole = WebBrowserJavaScriptConsole(self)
 self.__javascriptConsoleDock = QDockWidget(self.tr("JavaScript Console"))
 self.__javascriptConsoleDock.setObjectName("JavascriptConsole")
 self.__javascriptConsoleDock.setAllowedAreas(
 Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea
 )
 self.clearIconsAct.triggered.connect(self.__clearIconsDatabase)
 self.__actions.append(self.clearIconsAct)
 self.manageIconsAct = EricAction(
-self.tr("Manage saved Favicons"),
+self.tr("Manage Saved Favicons"),
 EricPixmapCache.getIcon("icons"),
-self.tr("Manage saved Favicons"),
+self.tr("Manage Saved Favicons"),
 0,
 0,
 self,
 "webbrowser_manage_icons_db",
 )
 self.manageIconsAct.setStatusTip(
 self.tr("Show a dialog to manage the saved favicons")
 )
 self.manageIconsAct.setWhatsThis(
 self.tr(
-"""<b>Manage saved Favicons</b>"""
+"""<b>Manage Saved Favicons</b>"""
 """<p>This shows a dialog to manage the saved favicons of"""
 """ previously visited URLs.</p>"""
 )
 )
 self.manageIconsAct.triggered.connect(self.__showWebIconsDialog)
 def __initMenus(self):
 """
 Private method to create the menus.
 """
+from .Bookmarks.BookmarksMenu import BookmarksMenuBarMenu
+from .History.HistoryMenu import HistoryMenu
+from .UserAgent.UserAgentMenu import UserAgentMenu
 mb = self.menuBar()
 menu = mb.addMenu(self.tr("&File"))
 menu.addAction(self.newTabAct)
 menu.addAction(self.newAct)
 menu.addSeparator()
 menu.addAction(self.pageSourceAct)
 menu.addAction(self.fullScreenAct)
 self.addActions(menu.actions())
-from .History.HistoryMenu import HistoryMenu
 self.historyMenu = HistoryMenu(self, self.__tabWidget)
 self.historyMenu.setTitle(self.tr("H&istory"))
 self.historyMenu.openUrl.connect(self.openUrl)
 self.historyMenu.newTab.connect(self.openUrlNewTab)
 self.historyMenu.newBackgroundTab.connect(self.openUrlNewBackgroundTab)
 historyActions.append(self.backAct)
 historyActions.append(self.forwardAct)
 historyActions.append(self.homeAct)
 self.historyMenu.setInitialActions(historyActions)
 self.addActions(historyActions)
-from .Bookmarks.BookmarksMenu import BookmarksMenuBarMenu
 self.bookmarksMenu = BookmarksMenuBarMenu(self)
 self.bookmarksMenu.setTitle(self.tr("&Bookmarks"))
 self.bookmarksMenu.openUrl.connect(self.openUrl)
 self.bookmarksMenu.newTab.connect(self.openUrlNewTab)
 menu.addSeparator()
 menu.addAction(self.safeBrowsingAct)
 menu.addSeparator()
 self.__settingsMenu = menu
 self.__settingsMenu.aboutToShow.connect(self.__aboutToShowSettingsMenu)
-from .UserAgent.UserAgentMenu import UserAgentMenu
 self.__userAgentMenu = UserAgentMenu(self.tr("Global User Agent"))
 menu.addMenu(self.__userAgentMenu)
 menu.addAction(self.userAgentManagerAct)
 menu.addSeparator()
 @param title title for the bookmark
 @type str
 @param res result of the JavaScript
 @type list
 """
+from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 description = ""
 for meta in res:
 if meta["name"] == "description":
 description = meta["content"]
-from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 dlg = AddBookmarkDialog()
 dlg.setUrl(url)
 dlg.setTitle(title)
 dlg.setDescription(description)
 @param title title for the bookmark
 @type str
 @param res result of the JavaScript
 @type list
 """
+from .Bookmarks.BookmarkNode import BookmarkNode
 description = ""
 for meta in res:
 if meta["name"] == "description":
 description = meta["content"]
-from .Bookmarks.BookmarkNode import BookmarkNode
 bookmark = BookmarkNode(BookmarkNode.Bookmark)
 bookmark.url = url
 bookmark.title = title
 bookmark.desc = description
 """
 Class method to get a reference to the network manager object.
 @return reference to the network access manager (NetworkManager)
 """
+from .Network.NetworkManager import NetworkManager
 if cls._networkManager is None:
-from .Network.NetworkManager import NetworkManager
 cls._networkManager = NetworkManager(cls.helpEngine())
 return cls._networkManager
 @classmethod
 """
 Class method to get a reference to the cookie jar.
 @return reference to the cookie jar (CookieJar)
 """
+from .CookieJar.CookieJar import CookieJar
 if cls._cookieJar is None:
-from .CookieJar.CookieJar import CookieJar
 cls._cookieJar = CookieJar()
 return cls._cookieJar
 @pyqtSlot()
 @pyqtSlot()
 def __showWebIconsDialog(self):
 """
 Private slot to show a dialog to manage the favicons database.
 """
-WebIconProvider.instance().showWebIconDialog()
+WebIconProvider.instance().showWebIconDialog(self)
 @pyqtSlot(QUrl)
 def urlHandler(self, url):
 """
 Public slot used as desktop URL handler.
 def __manageQtHelpDocumentation(self):
 """
 Private slot to manage the QtHelp documentation database.
 """
 if WebBrowserWindow._useQtHelp:
-from .QtHelp.QtHelpDocumentationConfigurationDialog import (
+from .QtHelp.QtHelpDocumentationConfigurationDialog import (  # __IGNORE_WARNING__
 QtHelpDocumentationConfigurationDialog,
 )
 dlg = QtHelpDocumentationConfigurationDialog(self.__helpEngine, self)
 dlg.exec()
 """
 Private slot to look for new documentation to be loaded into the
 help database.
 """
 if WebBrowserWindow._useQtHelp:
-from .QtHelp.HelpDocsInstaller import HelpDocsInstaller
+from .QtHelp.HelpDocsInstaller import (  # __IGNORE_WARNING_I101__
+HelpDocsInstaller,
+)
 self.__helpInstaller = HelpDocsInstaller(self.__helpEngine.collectionFile())
 self.__helpInstaller.errorMessage.connect(self.__showInstallationError)
 self.__helpInstaller.docsInstalled.connect(self.__docsInstalled)
 @pyqtSlot()
 def __showCertificateErrorsDialog(self):
 """
 Private slot to show the certificate errors management dialog.
 """
-self.networkManager().showSslErrorExceptionsDialog()
+self.networkManager().showSslErrorExceptionsDialog(self)
 @pyqtSlot()
 def __showAdBlockDialog(self):
 """
 Private slot to show the AdBlock configuration dialog.
 """
-self.adBlockManager().showDialog()
+self.adBlockManager().showDialog(self)
 @pyqtSlot()
 def __showPersonalInformationDialog(self):
 """
 Private slot to show the Personal Information configuration dialog.
 """
-self.personalInformationManager().showConfigurationDialog()
+self.personalInformationManager().showConfigurationDialog(parent=self)
 @pyqtSlot()
 def __showGreaseMonkeyConfigDialog(self):
 """
 Private slot to show the GreaseMonkey scripts configuration dialog.
 """
-self.greaseMonkeyManager().showConfigurationDialog()
+self.greaseMonkeyManager().showConfigurationDialog(parent=self)
 @pyqtSlot()
 def __showFeaturePermissionDialog(self):
 """
 Private slot to show the feature permission dialog.
 """
-self.featurePermissionManager().showFeaturePermissionsDialog()
+self.featurePermissionManager().showFeaturePermissionsDialog(self)
 @pyqtSlot()
 def __showZoomValuesDialog(self):
 """
 Private slot to show the zoom values management dialog.
 """
 Class method to get a reference to the bookmarks manager.
 @return reference to the bookmarks manager (BookmarksManager)
 """
+from .Bookmarks.BookmarksManager import BookmarksManager
 if cls._bookmarksManager is None:
-from .Bookmarks.BookmarksManager import BookmarksManager
 cls._bookmarksManager = BookmarksManager()
 return cls._bookmarksManager
 @pyqtSlot(QUrl)
 """
 Class method to get a reference to the history manager.
 @return reference to the history manager (HistoryManager)
 """
+from .History.HistoryManager import HistoryManager
 if cls._historyManager is None:
-from .History.HistoryManager import HistoryManager
 cls._historyManager = HistoryManager()
 return cls._historyManager
 @classmethod
 """
 Class method to get a reference to the password manager.
 @return reference to the password manager (PasswordManager)
 """
+from .Passwords.PasswordManager import PasswordManager
 if cls._passwordManager is None:
-from .Passwords.PasswordManager import PasswordManager
 cls._passwordManager = PasswordManager()
 return cls._passwordManager
 @classmethod
 """
 Class method to get a reference to the AdBlock manager.
 @return reference to the AdBlock manager (AdBlockManager)
 """
+from .AdBlock.AdBlockManager import AdBlockManager
 if cls._adblockManager is None:
-from .AdBlock.AdBlockManager import AdBlockManager
 cls._adblockManager = AdBlockManager()
 return cls._adblockManager
 def adBlockIcon(self):
 """
 Class method to get a reference to the download manager.
 @return reference to the download manager (DownloadManager)
 """
+from .Download.DownloadManager import DownloadManager
 if cls._downloadManager is None:
-from .Download.DownloadManager import DownloadManager
 cls._downloadManager = DownloadManager()
 return cls._downloadManager
 @classmethod
 Class method to get a reference to the personal information manager.
 @return reference to the personal information manager
 (PersonalInformationManager)
 """
+from .PersonalInformationManager import PersonalInformationManager
 if cls._personalInformationManager is None:
-from .PersonalInformationManager import PersonalInformationManager
 cls._personalInformationManager = (
 PersonalInformationManager.PersonalInformationManager()
 )
 return cls._personalInformationManager
 """
 Class method to get a reference to the GreaseMonkey manager.
 @return reference to the GreaseMonkey manager (GreaseMonkeyManager)
 """
+from .GreaseMonkey.GreaseMonkeyManager import GreaseMonkeyManager
 if cls._greaseMonkeyManager is None:
-from .GreaseMonkey.GreaseMonkeyManager import GreaseMonkeyManager
 cls._greaseMonkeyManager = GreaseMonkeyManager()
 return cls._greaseMonkeyManager
 @classmethod
 Class method to get a reference to the feature permission manager.
 @return reference to the feature permission manager
 @rtype FeaturePermissionManager
 """
+from .FeaturePermissions.FeaturePermissionManager import (
+FeaturePermissionManager,
+)
 if cls._featurePermissionManager is None:
-from .FeaturePermissions.FeaturePermissionManager import (
-FeaturePermissionManager,
-)
 cls._featurePermissionManager = FeaturePermissionManager()
 return cls._featurePermissionManager
 @classmethod
 Class method to get a reference to the image search engine.
 @return reference to the image finder object
 @rtype ImageSearchEngine
 """
+from .ImageSearch.ImageSearchEngine import ImageSearchEngine
 if cls._imageSearchEngine is None:
-from .ImageSearch.ImageSearchEngine import ImageSearchEngine
 cls._imageSearchEngine = ImageSearchEngine()
 return cls._imageSearchEngine
 @classmethod
 Class method to get a reference to the auto scroller.
 @return reference to the auto scroller object
 @rtype AutoScroller
 """
+from .AutoScroll.AutoScroller import AutoScroller
 if cls._autoScroller is None:
-from .AutoScroll.AutoScroller import AutoScroller
 cls._autoScroller = AutoScroller()
 return cls._autoScroller
 @classmethod
 Class method to get a reference to the tab manager widget.
 @return reference to the tab manager widget
 @rtype TabManagerWidget
 """
+from .TabManager.TabManagerWidget import TabManagerWidget
 if cls._tabManager is None:
-from .TabManager.TabManagerWidget import TabManagerWidget
 cls._tabManager = TabManagerWidget(cls.mainWindow())
 # do the connections
 for window in cls.mainWindows():
 cls._tabManager.mainWindowCreated(window, False)
 """
 Class method to get a reference to the RSS feeds manager.
 @return reference to the RSS feeds manager (FeedsManager)
 """
+from .Feeds.FeedsManager import FeedsManager
 if cls._feedsManager is None:
-from .Feeds.FeedsManager import FeedsManager
 cls._feedsManager = FeedsManager()
 return cls._feedsManager
 @pyqtSlot()
 """
 Class method to get a reference to the user agents manager.
 @return reference to the user agents manager (UserAgentManager)
 """
+from .UserAgent.UserAgentManager import UserAgentManager
 if cls._userAgentsManager is None:
-from .UserAgent.UserAgentManager import UserAgentManager
 cls._userAgentsManager = UserAgentManager()
 return cls._userAgentsManager
 @pyqtSlot()
 """
 Class method to get a reference to the data synchronization manager.
 @return reference to the data synchronization manager (SyncManager)
 """
+from .Sync.SyncManager import SyncManager
 if cls._syncManager is None:
-from .Sync.SyncManager import SyncManager
 cls._syncManager = SyncManager()
 return cls._syncManager
 @pyqtSlot()
 """
 Class method to get a reference to the speed dial.
 @return reference to the speed dial (SpeedDial)
 """
+from .SpeedDial.SpeedDial import SpeedDial
 if cls._speedDial is None:
-from .SpeedDial.SpeedDial import SpeedDial
 cls._speedDial = SpeedDial()
 return cls._speedDial
 def keyPressEvent(self, evt):
 """
 Private method to set a user style sheet.
 @param styleSheetFile name of the user style sheet file (string)
 """
+from .WebBrowserPage import WebBrowserPage
 name = "_eric_userstylesheet"
 userStyle = ""
 userStyle += WebBrowserTools.readAllFileContents(styleSheetFile).replace(
 "\n", ""
 scripts = self.webProfile().scripts().find(name)
 if scripts:
 self.webProfile().scripts().remove(scripts[0])
 if userStyle:
-from .WebBrowserPage import WebBrowserPage
 script = QWebEngineScript()
 script.setName(name)
 script.setInjectionPoint(QWebEngineScript.InjectionPoint.DocumentCreation)
 script.setWorldId(WebBrowserPage.SafeJsWorld)
 script.setRunsOnSubFrames(True)
 @type NotificationTypes
 @param timeout time in seconds the notification should be shown
 (None = use configured timeout, 0 = indefinitely)
 @type int
 """
+from eric7.UI.NotificationWidget import NotificationWidget
 if cls._notification is None:
-from eric7.UI.NotificationWidget import NotificationWidget
 cls._notification = NotificationWidget()
 if timeout is None:
 timeout = Preferences.getUI("NotificationTimeout")
 cls._notification.showNotification(
 @param private flag indicating the privacy mode
 @type bool
 @return reference to the web profile object
 @rtype QWebEngineProfile
 """
+from .WebBrowserPage import WebBrowserPage
 if cls._webProfile is None:
 if private:
 cls._webProfile = QWebEngineProfile()
 else:
 cls._webProfile = QWebEngineProfile.defaultProfile()
 cls._webProfile.setSpellCheckLanguages(
 Preferences.getWebBrowser("SpellCheckLanguages")
 )
 # Setup QWebChannel user scripts
-from .WebBrowserPage import WebBrowserPage
 # WebChannel for SafeJsWorld
 script = QWebEngineScript()
 script.setName("_eric_webchannel")
 script.setInjectionPoint(QWebEngineScript.InjectionPoint.DocumentCreation)
 script.setWorldId(WebBrowserPage.SafeJsWorld)
 Class method to get a reference to the session manager.
 @return reference to the session manager
 @rtype SessionManager
 """
+from .Session.SessionManager import SessionManager
 if cls._sessionManager is None and not cls._isPrivate:
-from .Session.SessionManager import SessionManager
 cls._sessionManager = SessionManager()
 return cls._sessionManager
 @pyqtSlot()
 Class method to get a reference to the safe browsing interface.
 @return reference to the safe browsing manager
 @rtype SafeBrowsingManager
 """
+from .SafeBrowsing.SafeBrowsingManager import SafeBrowsingManager
 if cls._safeBrowsingManager is None:
-from .SafeBrowsing.SafeBrowsingManager import SafeBrowsingManager
 cls._safeBrowsingManager = SafeBrowsingManager()
 return cls._safeBrowsingManager
 @pyqtSlot()
 Class method to get a reference to the protocol handler manager.
 @return reference to the protocol handler manager
 @rtype ProtocolHandlerManager
 """
+from .Network.ProtocolHandlerManager import ProtocolHandlerManager
 if cls._protocolHandlerManager is None:
-from .Network.ProtocolHandlerManager import ProtocolHandlerManager
 cls._protocolHandlerManager = ProtocolHandlerManager()
 return cls._protocolHandlerManager
 @pyqtSlot()
 def __configShortcuts(self):
 """
 Private slot to configure the keyboard shortcuts.
 """
 if self.__shortcutsDialog is None:
-from eric7.Preferences.ShortcutsDialog import ShortcutsDialog
 self.__shortcutsDialog = ShortcutsDialog(self)
 self.__shortcutsDialog.populate(helpViewer=self)
 self.__shortcutsDialog.show()
 @pyqtSlot()
 if fpath.exists()
 else True
 )
 if ok:
-from eric7.Preferences import Shortcuts
 Shortcuts.exportShortcuts(fn, helpViewer=self)
 @pyqtSlot()
 def __importShortcuts(self):
 """
 "Keyboard Shortcuts File (*.ekj);;" "XML Keyboard shortcut file (*.e4k)"
 ),
 )
 if fn:
-from eric7.Preferences import Shortcuts
 Shortcuts.importShortcuts(fn, helpViewer=self)

Mercurial Repositories > eric / file comparison

comparison: src/eric7/WebBrowser/WebBrowserWindow.py

src/eric7/WebBrowser/WebBrowserWindow.py