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

-:0b936ff1bbb9
+:a2bc06a54d9d
 from eric7.EricGui import EricPixmapCache
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.Globals import qVersionTuple
 from eric7.WebBrowser.WebBrowserWindow import WebBrowserWindow
+from eric7.WebBrowser.ZoomManager import ZoomManager
 from . import WebInspector
 from .Tools import Scripts
 from .Tools.WebBrowserTools import getHtmlPage, pixmapToDataUrl
 from .Tools.WebIconLoader import WebIconLoader
 """
 if value != self.__currentZoom:
 self.setZoomFactor(value / 100.0)
 self.__currentZoom = value
 if saveValue and not self.__mw.isPrivate():
-from eric7.WebBrowser.ZoomManager import ZoomManager
 ZoomManager.instance().setZoomValue(self.url(), value)
 self.zoomValueChanged.emit(value)
 def zoomValue(self):
 """
 @param menu reference to the menu to be populated
 @type QMenu
 @param hitTest reference to the hit test object
 @type WebHitTestResult
 """
+from .OpenSearch.OpenSearchEngineAction import OpenSearchEngineAction
+from .WebBrowserLanguagesDialog import WebBrowserLanguagesDialog
 if not menu.isEmpty():
 menu.addSeparator()
 menu.addAction(self.__mw.copyAct)
 menu.addSeparator()
 if engineName:
 menu.addAction(
 self.tr("Search with '{0}'").format(engineName),
 self.__searchDefaultRequested,
 )
-from .OpenSearch.OpenSearchEngineAction import OpenSearchEngineAction
 self.__searchMenu = menu.addMenu(self.tr("Search with..."))
 engineNames = self.__mw.openSearchManager().allEnginesNames()
 for engineName in engineNames:
 engine = self.__mw.openSearchManager().engine(engineName)
 self.__searchMenu.addAction(act)
 self.__searchMenu.triggered.connect(self.__searchRequested)
 menu.addSeparator()
-from .WebBrowserLanguagesDialog import WebBrowserLanguagesDialog
 languages = Preferences.toList(
 Preferences.getSettings().value(
 "WebBrowser/AcceptLanguages",
 WebBrowserLanguagesDialog.defaultAcceptLanguages(),
 )
 Private method to populate the basic context menu.
 @param menu reference to the menu to be populated
 @type QMenu
 """
+from .UserAgent.UserAgentMenu import UserAgentMenu
+from .WebBrowserLanguagesDialog import WebBrowserLanguagesDialog
 menu.addAction(self.__mw.newTabAct)
 menu.addAction(self.__mw.newAct)
 menu.addSeparator()
 if self.__mw.saveAsAct is not None:
 menu.addAction(self.__mw.saveAsAct)
 EricPixmapCache.getIcon("mailSend"), self.tr("Send Page URL")
 )
 act.setData(self.url())
 act.triggered.connect(functools.partial(self.__sendLink, act))
 menu.addSeparator()
-from .UserAgent.UserAgentMenu import UserAgentMenu
 self.__userAgentMenu = UserAgentMenu(self.tr("User Agent"), url=self.url())
 menu.addMenu(self.__userAgentMenu)
 menu.addSeparator()
 menu.addAction(self.__mw.backAct)
 EricPixmapCache.getIcon("w3"), self.tr("Validate Page")
 )
 act.setData(w3url)
 act.triggered.connect(functools.partial(self.__openLinkInNewTab, act))
-from .WebBrowserLanguagesDialog import WebBrowserLanguagesDialog
 languages = Preferences.toList(
 Preferences.getSettings().value(
 "WebBrowser/AcceptLanguages",
 WebBrowserLanguagesDialog.defaultAcceptLanguages(),
 )
 @param act reference to the action to be populated upon success
 @type QAction
 @param pos position to be tested
 @type QPoint
 """
+from .Tools import Scripts
 self.__clickedPos = self.mapToViewport(pos)
-from .Tools import Scripts
 script = Scripts.getFormData(self.__clickedPos)
 self.page().runJavaScript(
 script,
 WebBrowserPage.SafeJsWorld,
 Private slot to bookmark a link via the context menu.
 @param act reference to the action that triggered
 @type QAction
 """
+from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 url = act.data()
 if url.isEmpty():
 return
-from .Bookmarks.AddBookmarkDialog import AddBookmarkDialog
 dlg = AddBookmarkDialog()
 dlg.setUrl(bytes(url.toEncoded()).decode())
 dlg.exec()
 @param res reference to the result list containing all
 meta attributes
 @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(bytes(self.url().toEncoded()).decode())
 dlg.setTitle(self.title())
 dlg.setDescription(description)
 Private slot handling the loaded web site icon.
 @param icon web site icon
 @type QIcon
 """
+from eric7.WebBrowser.Tools import WebIconProvider
 self.__siteIcon = icon
-from eric7.WebBrowser.Tools import WebIconProvider
 WebIconProvider.instance().saveIcon(self)
 self.faviconChanged.emit()
 Public method to get the web site icon.
 @return web site icon
 @rtype QIcon
 """
+from eric7.WebBrowser.Tools import WebIconProvider
 if not self.__siteIcon.isNull():
 return QIcon(self.__siteIcon)
-from eric7.WebBrowser.Tools import WebIconProvider
 return WebIconProvider.instance().iconForUrl(self.url())
 def title(self):
 """
 self.__progress = 0
 QApplication.processEvents()
 QTimer.singleShot(200, self.__renderPreview)
-from eric7.WebBrowser.ZoomManager import ZoomManager
 zoomValue = ZoomManager.instance().zoomValue(self.url())
 self.setZoomValue(zoomValue)
 if ok:
 self.__mw.historyManager().addHistoryEntry(self)
 Private slot to adjust the 'lastModified' value of bookmarks.
 @param lastModified last modified value
 @type str
 """
+from .Bookmarks.BookmarkNode import BookmarkNode
 modified = QDateTime.fromString(lastModified, "MM/dd/yyyy hh:mm:ss")
 if modified.isValid():
-from eric7.WebBrowser.WebBrowserWindow import WebBrowserWindow
-from .Bookmarks.BookmarkNode import BookmarkNode
 manager = WebBrowserWindow.bookmarksManager()
 for bookmark in manager.bookmarksForUrl(self.url()):
 manager.setTimestamp(bookmark, BookmarkNode.TsModified, modified)
 def isLoading(self):
 generated by getSessionData()
 @type dict
 @return tuple containing the title, URL and web icon
 @rtype tuple of (str, str, QIcon)
 """
+from eric7.WebBrowser.Tools import WebIconProvider
 title = sessionData.get("Title", "")
 urlStr = sessionData.get("Url", "")
 if "Icon" in sessionData:
 iconArray = QByteArray.fromBase64(sessionData["Icon"].encode("ascii"))
 stream = QDataStream(iconArray, QIODevice.OpenModeFlag.ReadOnly)
 icon = QIcon()
 stream >> icon
 else:
-from eric7.WebBrowser.Tools import WebIconProvider
 icon = WebIconProvider.instance().iconForUrl(QUrl.fromUserInput(urlStr))
 return title, urlStr, icon
 ###########################################################################
 Private slot to handle quota requests of the web page.
 @param quotaRequest reference to the quota request object
 @type QWebEngineQuotaRequest
 """
+from .Download.DownloadUtilities import dataString
 acceptRequest = Preferences.getWebBrowser("AcceptQuotaRequest")
 # map yes/no/ask from (0, 1, 2)
 if acceptRequest == 0:
 # always yes
 ok = True
 elif acceptRequest == 1:
 # always no
 ok = False
 else:
 # ask user
-from .Download.DownloadUtilities import dataString
 sizeStr = dataString(quotaRequest.requestedSize())
 ok = EricMessageBox.yesNo(
 self,
 self.tr("Quota Request"),
 @param clientCertificateSelection list of client SSL certificates
 found in system's client certificate store
 @type QWebEngineClientCertificateSelection
 """
+from eric7.EricNetwork.EricSslCertificateSelectionDialog import (
+EricSslCertificateSelectionDialog,
+)
 certificates = clientCertificateSelection.certificates()
 if len(certificates) == 0:
 clientCertificateSelection.selectNone()
 elif len(certificates) == 1:
 clientCertificateSelection.select(certificates[0])
 else:
 certificate = None
-from eric7.EricNetwork.EricSslCertificateSelectionDialog import (
-EricSslCertificateSelectionDialog,
-)
 dlg = EricSslCertificateSelectionDialog(certificates, self)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 certificate = dlg.getSelectedCertificate()
 if certificate is None:
 Private slot to handle file system access requests of the web page.
 @param accessRequest reference to the file system access request object
 @type QWebEngineFileSystemAccessRequest
 """
-from PyQt6.QtWebEngineCore import QWebEngineFileSystemAccessRequest
+from PyQt6.QtWebEngineCore import (  # __IGNORE_WARNING_I102__
+QWebEngineFileSystemAccessRequest,
+)
 acceptRequest = Preferences.getWebBrowser("AcceptFileSystemAccessRequest")
 # map yes/no/ask from (0, 1, 2)
 if acceptRequest == 0:
 # always yes

Mercurial Repositories > eric / file comparison

comparison: src/eric7/WebBrowser/WebBrowserView.py

src/eric7/WebBrowser/WebBrowserView.py