def languagesChanged(self):
"""
Public slot to (re-)load the list of accepted languages.
"""
from WebBrowser.WebBrowserLanguagesDialog import (
WebBrowserLanguagesDialog
)
languages = Preferences.toList(
Preferences.Prefs.settings.value(
"WebBrowser/AcceptLanguages",
WebBrowserLanguagesDialog.defaultAcceptLanguages()))
self.__acceptLanguage = WebBrowserLanguagesDialog.httpString(languages)
WebBrowserWindow.webProfile().setHttpAcceptLanguage(
self.__acceptLanguage)
def __init__(self, engine, parent=None):
"""
Constructor
@param engine reference to the help engine (QHelpEngine)
@param parent reference to the parent object (QObject)
"""
super(NetworkManager, self).__init__(parent)
from E5Network.E5NetworkProxyFactory import E5NetworkProxyFactory
self.__proxyFactory = E5NetworkProxyFactory()
if Preferences.getUI("UseSystemProxy"):
QNetworkProxyFactory.setUseSystemConfiguration(True)
else:
QNetworkProxyFactory.setApplicationProxyFactory(
self.__proxyFactory)
QNetworkProxyFactory.setUseSystemConfiguration(False)
self.languagesChanged()
if SSL_AVAILABLE:
self.__sslErrorHandler = E5SslErrorHandler(self)
self.sslErrors.connect(self.__sslErrorHandler.sslErrorsReplySlot)
self.__temporarilyIgnoredSslErrors = {}
self.__permanentlyIgnoredSslErrors = {}
# dictionaries of permanently and temporarily ignored SSL errors
self.__loaded = False
self.__saveTimer = AutoSaver(self, self.__save)
self.changed.connect(self.__saveTimer.changeOccurred)
self.proxyAuthenticationRequired.connect(proxyAuthenticationRequired)
self.authenticationRequired.connect(
lambda reply, auth: self.authentication(reply.url(), auth))
from .EricSchemeHandler import EricSchemeHandler
self.__ericSchemeHandler = EricSchemeHandler()
WebBrowserWindow.webProfile().installUrlSchemeHandler(
QByteArray(b"eric"), self.__ericSchemeHandler)
if engine:
from .QtHelpSchemeHandler import QtHelpSchemeHandler
self.__qtHelpSchemeHandler = QtHelpSchemeHandler(engine)
WebBrowserWindow.webProfile().installUrlSchemeHandler(
QByteArray(b"qthelp"), self.__qtHelpSchemeHandler)
self.__interceptor = NetworkUrlInterceptor(self)
try:
WebBrowserWindow.webProfile().setUrlRequestInterceptor(
self.__interceptor)
except AttributeError:
# Qt < 5.13
WebBrowserWindow.webProfile().setRequestInterceptor(
self.__interceptor)
WebBrowserWindow.cookieJar()
def __load(self):
"""
Private slot to load the available scripts into the manager.
"""
scriptsDir = QDir(self.scriptsDirectory())
if not scriptsDir.exists():
scriptsDir.mkpath(self.scriptsDirectory())
if not scriptsDir.exists("requires"):
scriptsDir.mkdir("requires")
self.__disabledScripts = Preferences.getWebBrowser(
"GreaseMonkeyDisabledScripts")
from .GreaseMonkeyScript import GreaseMonkeyScript
for fileName in scriptsDir.entryList(["*.js"], QDir.Files):
absolutePath = scriptsDir.absoluteFilePath(fileName)
script = GreaseMonkeyScript(self, absolutePath)
if not script.isValid():
del script
continue
self.__scripts.append(script)
if script.fullName() in self.__disabledScripts:
script.setEnabled(False)
else:
collection = WebBrowserWindow.webProfile().scripts()
collection.insert(script.webScript())
self.__jsObject.setSettingsFile(
os.path.join(Utilities.getConfigDir(), "web_browser",
"greasemonkey_values.ini"))
ExternalJsObject.registerExtraObject("GreaseMonkey", self.__jsObject)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent object (QObject)
"""
super(CookieJar, self).__init__(parent)
self.__loaded = False
self.__acceptCookies = self.AcceptOnlyFromSitesNavigatedTo
self.__saveTimer = AutoSaver(self, self.__save)
self.__cookiesFile = os.path.join(Utilities.getConfigDir(),
"web_browser", "cookies.ini")
self.__store = WebBrowserWindow.webProfile().cookieStore()
try:
self.__store.setCookieFilter(self.__cookieFilter)
except AttributeError:
# pre Qt 5.11
pass
self.__store.cookieAdded.connect(self.__cookieAdded)
self.__store.cookieRemoved.connect(self.__cookieRemoved)
self.__load()
self.__store.loadAllCookies()
def removeScript(self, script, removeFile=True):
"""
Public method to remove a script.
@param script script to be removed (GreaseMonkeyScript)
@param removeFile flag indicating to remove the script file as well
(bool)
@return flag indicating success (boolean)
"""
if not script:
return False
try:
self.__scripts.remove(script)
except ValueError:
pass
fullName = script.fullName()
collection = WebBrowserWindow.webProfile().scripts()
collection.remove(collection.findScript(fullName))
if fullName in self.__disabledScripts:
self.__disabledScripts.remove(fullName)
if removeFile:
QFile.remove(script.fileName())
del script
self.scriptsChanged.emit()
return True
def __scriptChanged(self, script):
"""
Private slot handling a changed script.
@param script reference to the changed script
@type GreaseMonkeyScript
"""
fullName = script.fullName()
collection = WebBrowserWindow.webProfile().scripts()
collection.remove(collection.findScript(fullName))
collection.insert(script.webScript())
def disableScript(self, script):
"""
Public method to disable the given script.
@param script script to be disabled (GreaseMonkeyScript)
"""
script.setEnabled(False)
fullName = script.fullName()
if fullName not in self.__disabledScripts:
self.__disabledScripts.append(fullName)
collection = WebBrowserWindow.webProfile().scripts()
collection.remove(collection.findScript(fullName))
def enableScript(self, script):
"""
Public method to enable the given script.
@param script script to be enabled (GreaseMonkeyScript)
"""
script.setEnabled(True)
fullName = script.fullName()
if fullName in self.__disabledScripts:
self.__disabledScripts.remove(fullName)
collection = WebBrowserWindow.webProfile().scripts()
collection.insert(script.webScript())
def userAgentForUrl(cls, url):
"""
Class method to determine the user agent for the given URL.
@param url URL to determine user agent for (QUrl)
@return user agent string (string)
"""
agent = WebBrowserWindow.userAgentsManager().userAgentForUrl(url)
if agent == "":
# no agent string specified for the given host -> use global one
agent = Preferences.getWebBrowser("UserAgent")
if agent == "":
# no global agent string specified -> use default one
agent = WebBrowserWindow.webProfile().httpUserAgent()
return agent
def addScript(self, script):
"""
Public method to add a script.
@param script script to be added (GreaseMonkeyScript)
@return flag indicating success (boolean)
"""
if not script or not script.isValid():
return False
self.__scripts.append(script)
script.scriptChanged.connect(lambda: self.__scriptChanged(script))
collection = WebBrowserWindow.webProfile().scripts()
collection.insert(script.webScript())
self.scriptsChanged.emit()
return True
def __init__(self, parent=None):
"""
Constructor
@param parent parent widget of this window (QWidget)
"""
super(WebBrowserPage, self).__init__(WebBrowserWindow.webProfile(),
parent)
self.__printer = None
self.__badSite = False
self.__registerProtocolHandlerRequest = None
self.featurePermissionRequested.connect(
self.__featurePermissionRequested)
self.authenticationRequired.connect(
lambda url, auth: WebBrowserWindow.networkManager().authentication(
url, auth, self))
self.proxyAuthenticationRequired.connect(
WebBrowserWindow.networkManager().proxyAuthentication)
self.fullScreenRequested.connect(self.__fullScreenRequested)
self.urlChanged.connect(self.__urlChanged)
self.contentsSizeChanged.connect(self.__contentsSizeChanged)
try:
self.registerProtocolHandlerRequested.connect(
self.__registerProtocolHandlerRequested)
except AttributeError:
# defined for Qt >= 5.11
pass
# Workaround for changing webchannel world inside
# acceptNavigationRequest not working
self.__channelUrl = QUrl()
self.__channelWorldId = -1
self.__setupChannelTimer = QTimer(self)
self.__setupChannelTimer.setSingleShot(True)
self.__setupChannelTimer.setInterval(100)
self.__setupChannelTimer.timeout.connect(self.__setupChannelTimeout)