def save(self):
"""
Public method to save the zoom values.
"""
if not self.__loaded:
return
from WebBrowser.WebBrowserWindow import WebBrowserWindow
if not WebBrowserWindow.isPrivate():
dbString = json.dumps(self.__zoomDB)
Preferences.setWebBrowser("ZoomValuesDB", dbString)
def certificateError(self, error):
"""
Public method to handle SSL certificate errors.
@param error object containing the certificate error information
@type QWebEngineCertificateError
@return flag indicating to ignore this error
@rtype bool
"""
return WebBrowserWindow.networkManager().certificateError(
error, self.view())
def __featurePermissionRequested(self, url, feature):
"""
Private slot handling a feature permission request.
@param url url requesting the feature
@type QUrl
@param feature requested feature
@type QWebEnginePage.Feature
"""
manager = WebBrowserWindow.featurePermissionManager()
manager.requestFeaturePermission(self, url, feature)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(SessionManagerDialog, self).__init__(parent)
self.setupUi(self)
self.setAttribute(Qt.WA_DeleteOnClose)
self.newButton.clicked.connect(self.__newSession)
self.renameButton.clicked.connect(self.__renameSession)
self.cloneButton.clicked.connect(self.__cloneSession)
self.deleteButton.clicked.connect(self.__deleteSession)
self.switchButton.clicked.connect(self.__switchToSession)
self.sessionsList.currentItemChanged.connect(self.__updateButtons)
self.__refresh()
WebBrowserWindow.sessionManager().sessionsMetaDataChanged.connect(
self.__refresh)
def __initialSync(self):
"""
Private slot to do the initial synchronization.
"""
QCoreApplication.processEvents()
# Bookmarks
if Preferences.getWebBrowser("SyncBookmarks"):
self.__initialSyncFile(
"bookmarks",
WebBrowserWindow.bookmarksManager().getFileName())
QCoreApplication.processEvents()
# History
if Preferences.getWebBrowser("SyncHistory"):
self.__initialSyncFile(
"history",
WebBrowserWindow.historyManager().getFileName())
QCoreApplication.processEvents()
# Passwords
if Preferences.getWebBrowser("SyncPasswords"):
self.__initialSyncFile(
"passwords",
WebBrowserWindow.passwordManager().getFileName())
QCoreApplication.processEvents()
# User Agent Settings
if Preferences.getWebBrowser("SyncUserAgents"):
self.__initialSyncFile(
"useragents",
WebBrowserWindow.userAgentsManager().getFileName())
QCoreApplication.processEvents()
# Speed Dial Settings
if Preferences.getWebBrowser("SyncSpeedDial"):
self.__initialSyncFile("speeddial",
WebBrowserWindow.speedDial().getFileName())
self.__forceUpload = False
self.syncMessage.emit(self.tr("Synchronization finished"))
def __init__(self, mainWindow, parent=None):
"""
Constructor
@param mainWindow reference to the main window (WebBrowserWindow)
@param parent reference to the parent widget (WebBrowserView)
"""
E5LineEdit.__init__(self, parent)
self.setInactiveText(self.tr("Enter the URL here."))
self.setWhatsThis(self.tr("Enter the URL here."))
self.__mw = mainWindow
self.__browser = None
self.__privateMode = WebBrowserWindow.isPrivate()
self.__bmActiveIcon = UI.PixmapCache.getIcon("bookmark16.png")
self.__bmInactiveIcon = QIcon(
self.__bmActiveIcon.pixmap(16, 16, QIcon.Disabled))
self.__safeBrowsingLabel = SafeBrowsingLabel(self)
self.addWidget(self.__safeBrowsingLabel, E5LineEdit.LeftSide)
self.__safeBrowsingLabel.setVisible(False)
self.__favicon = FavIconLabel(self)
self.addWidget(self.__favicon, E5LineEdit.LeftSide)
self.__rssButton = E5LineEditButton(self)
self.__rssButton.setIcon(UI.PixmapCache.getIcon("rss16.png"))
self.addWidget(self.__rssButton, E5LineEdit.RightSide)
self.__rssButton.setVisible(False)
self.__bookmarkButton = E5LineEditButton(self)
self.addWidget(self.__bookmarkButton, E5LineEdit.RightSide)
self.__bookmarkButton.setVisible(False)
self.__clearButton = E5LineEditButton(self)
self.__clearButton.setIcon(UI.PixmapCache.getIcon("clearLeft.png"))
self.addWidget(self.__clearButton, E5LineEdit.RightSide)
self.__clearButton.setVisible(False)
self.__safeBrowsingLabel.clicked.connect(self.__showThreatInfo)
self.__bookmarkButton.clicked.connect(self.__showBookmarkInfo)
self.__rssButton.clicked.connect(self.__rssClicked)
self.__clearButton.clicked.connect(self.clear)
self.textChanged.connect(self.__textChanged)
self.__mw.bookmarksManager().entryChanged.connect(
self.__bookmarkChanged)
self.__mw.bookmarksManager().entryAdded.connect(self.__bookmarkChanged)
self.__mw.bookmarksManager().entryRemoved.connect(
self.__bookmarkChanged)
self.__mw.speedDial().pagesChanged.connect(self.__bookmarkChanged)
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 __syncFinished(self, type_, status, download):
"""
Private slot to handle a finished synchronization event.
@param type_ type of the synchronization event (string one
of "bookmarks", "history", "passwords", "useragents" or
"speeddial")
@param status flag indicating success (boolean)
@param download flag indicating a download of a file (boolean)
"""
if status and download:
if type_ == "bookmarks":
WebBrowserWindow.bookmarksManager().reload()
elif type_ == "history":
WebBrowserWindow.historyManager().reload()
elif type_ == "passwords":
WebBrowserWindow.passwordManager().reload()
elif type_ == "useragents":
WebBrowserWindow.userAgentsManager().reload()
elif type_ == "speeddial":
WebBrowserWindow.speedDial().reload()
self.syncFinished.emit(type_, status, download)
def __addFeed(self, button):
"""
Private slot to add a RSS feed.
@param button reference to the feed button
@type QPushButton
"""
urlString = button.feed[1]
url = QUrl(urlString)
if url.isRelative():
url = self.__browser.url().resolved(url)
urlString = url.toDisplayString(QUrl.FullyDecoded)
if not url.isValid():
return
if button.feed[0]:
title = button.feed[0]
else:
title = self.__browser.url().host()
from WebBrowser.WebBrowserWindow import WebBrowserWindow
feedsManager = WebBrowserWindow.feedsManager()
if feedsManager.addFeed(urlString, title, self.__browser.icon()):
if WebBrowserWindow.notificationsEnabled():
WebBrowserWindow.showNotification(
UI.PixmapCache.getPixmap("rss48.png"),
self.tr("Add RSS Feed"),
self.tr("""The feed was added successfully."""))
else:
E5MessageBox.information(
self, self.tr("Add RSS Feed"),
self.tr("""The feed was added successfully."""))
else:
E5MessageBox.warning(
self, self.tr("Add RSS Feed"),
self.tr("""The feed was already added before."""))
self.close()
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)
def setRuleEnabled(self, offset, enabled):
"""
Public method to enable a specific rule.
@param offset offset of the rule
@type int
@param enabled new enabled state
@type bool
@return reference to the changed rule
@rtype AdBlockRule
"""
if offset >= len(self.__rules):
return None
rule = self.__rules[offset]
rule.setEnabled(enabled)
self.rulesEnabledChanged.emit()
if rule.isCSSRule():
from WebBrowser.WebBrowserWindow import WebBrowserWindow
WebBrowserWindow.mainWindow().reloadUserStyleSheet()
return rule
def data(self, index, role):
"""
Public method to get data from the model.
@param index index to get data for (QModelIndex)
@param role role of the data to retrieve (integer)
@return requested data
"""
if index.row() >= self.__manager.enginesCount() or index.row() < 0:
return None
engine = self.__manager.engine(
self.__manager.allEnginesNames()[index.row()])
if engine is None:
return None
if index.column() == 0:
if role == Qt.DisplayRole:
return engine.name()
elif role == Qt.DecorationRole:
image = engine.image()
if image.isNull():
from WebBrowser.WebBrowserWindow import WebBrowserWindow
icon = WebBrowserWindow.icon(QUrl(engine.imageUrl()))
else:
icon = QIcon(QPixmap.fromImage(image))
return icon
elif role == Qt.ToolTipRole:
description = self.tr(
"<strong>Description:</strong> {0}").format(
engine.description())
if engine.providesSuggestions():
description += "<br/>"
description += self.tr(
"<strong>Provides contextual suggestions</strong>")
return description
elif index.column() == 1:
if role in [Qt.EditRole, Qt.DisplayRole]:
return ",".join(self.__manager.keywordsForEngine(engine))
elif role == Qt.ToolTipRole:
return self.tr(
"Comma-separated list of keywords that may"
" be entered in the location bar followed by search terms"
" to search with this engine")
return None
def __parseUrl(self, url):
"""
Private method to parse the AdBlock URL for the subscription.
@param url AdBlock URL for the subscription
@type QUrl
"""
if url.scheme() != "abp":
return
if url.path() != "subscribe":
return
urlQuery = QUrlQuery(url)
self.__title = QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue("title").encode()))
self.__enabled = urlQuery.queryItemValue("enabled") != "false"
self.__location = QByteArray(QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue("location").encode()))
.encode("utf-8"))
# Check for required subscription
self.__requiresLocation = QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue(
"requiresLocation").encode()))
self.__requiresTitle = QUrl.fromPercentEncoding(
QByteArray(urlQuery.queryItemValue("requiresTitle").encode()))
if self.__requiresLocation and self.__requiresTitle:
from WebBrowser.WebBrowserWindow import WebBrowserWindow
WebBrowserWindow.adBlockManager().loadRequiredSubscription(
self.__requiresLocation, self.__requiresTitle)
lastUpdateString = urlQuery.queryItemValue("lastUpdate")
self.__lastUpdate = QDateTime.fromString(lastUpdateString,
Qt.ISODate)
self.__loadRules()
def __accepted(self):
"""
Private slot handling the accepted signal.
"""
if self.__manager.addScript(self.__script):
msg = self.tr(
"<p><b>{0}</b> installed successfully.</p>").format(
self.__script.name())
success = True
else:
msg = self.tr("<p>Cannot install script.</p>")
success = False
from WebBrowser.WebBrowserWindow import WebBrowserWindow
if success and WebBrowserWindow.notificationsEnabled():
WebBrowserWindow.showNotification(
UI.PixmapCache.getPixmap("greaseMonkey48.png"),
self.tr("GreaseMonkey Script Installation"),
msg)
else:
E5MessageBox.information(
self,
self.tr("GreaseMonkey Script Installation"),
msg)
def __taskbarButton(self):
"""
Private method to get a reference to the task bar button (Windows
only).
@return reference to the task bar button
@rtype QWinTaskbarButton or None
"""
if Globals.isWindowsPlatform():
from PyQt5.QtWinExtras import QWinTaskbarButton
if self.__winTaskbarButton is None:
window = WebBrowserWindow.mainWindow()
self.__winTaskbarButton = QWinTaskbarButton(
window.windowHandle())
self.__winTaskbarButton.progress().setRange(0, 100)
return self.__winTaskbarButton
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 __reloadFeed(self, itm):
"""
Private method to reload the given feed.
@param itm feed item to be reloaded (QTreeWidgetItem)
"""
urlString = itm.data(0, FeedsManager.UrlStringRole)
if urlString == "":
return
for child in itm.takeChildren():
del child
from WebBrowser.WebBrowserWindow import WebBrowserWindow
request = QNetworkRequest(QUrl(urlString))
reply = WebBrowserWindow.networkManager().get(request)
reply.finished.connect(lambda: self.__feedLoaded(reply))
self.__replies[id(reply)] = (reply, itm)
def __addEngineByUrl(self, url):
"""
Private method to add a new search engine given its URL.
@param url URL of the engine definition file (QUrl)
@return flag indicating success (boolean)
"""
if not url.isValid():
return False
from WebBrowser.WebBrowserWindow import WebBrowserWindow
reply = WebBrowserWindow.networkManager().get(QNetworkRequest(url))
reply.finished.connect(lambda: self.__engineFromUrlAvailable(reply))
reply.setParent(self)
self.__replies.append(reply)
return True
def setEnabled(self, enabled):
"""
Public slot to set the enabled state.
@param enabled flag indicating the enabled state
@type bool
"""
if self.isEnabled() == enabled:
return
from WebBrowser.WebBrowserWindow import WebBrowserWindow
self.__enabled = enabled
for mainWindow in WebBrowserWindow.mainWindows():
mainWindow.adBlockIcon().setEnabled(enabled)
if enabled:
self.__loadSubscriptions()
self.rulesChanged.emit()
self.enabledChanged.emit(enabled)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget (QWidget)
"""
super(DownloadManager, self).__init__(parent)
self.setupUi(self)
self.setWindowFlags(Qt.Window)
self.__winTaskbarButton = None
self.__saveTimer = AutoSaver(self, self.save)
self.__model = DownloadModel(self)
self.__manager = WebBrowserWindow.networkManager()
self.__iconProvider = None
self.__downloads = []
self.__downloadDirectory = ""
self.__loaded = False
self.__rowHeightMultiplier = 1.1
self.setDownloadDirectory(Preferences.getUI("DownloadPath"))
self.downloadsView.setShowGrid(False)
self.downloadsView.verticalHeader().hide()
self.downloadsView.horizontalHeader().hide()
self.downloadsView.setAlternatingRowColors(True)
self.downloadsView.horizontalHeader().setStretchLastSection(True)
self.downloadsView.setModel(self.__model)
self.downloadsView.setContextMenuPolicy(Qt.CustomContextMenu)
self.downloadsView.customContextMenuRequested.connect(
self.__customContextMenuRequested)
self.__clearShortcut = QShortcut(QKeySequence("Ctrl+L"), self)
self.__clearShortcut.activated.connect(self.on_cleanupButton_clicked)
self.__load()
self.__updateTimer = QBasicTimer()
def __rejectCookie(self, cookie, cookieDomain):
"""
Private method to test, if a cookie shall be rejected.
@param cookie cookie to be tested
@type QNetworkCookie
@param cookieDomain domain of the cookie
@type str
@return flag indicating the cookie shall be rejected
@rtype bool
"""
if not self.__loaded:
self.__load()
if self.__acceptCookies == self.AcceptNever:
res = self.__isOnDomainList(self.__exceptionsAllow, cookieDomain)
if not res:
return True
if self.__acceptCookies == self.AcceptAlways:
res = self.__isOnDomainList(self.__exceptionsBlock, cookieDomain)
if res:
return True
if self.__acceptCookies == self.AcceptOnlyFromSitesNavigatedTo:
mainWindow = WebBrowserWindow.mainWindow()
if mainWindow is not None:
browser = mainWindow.getWindow().currentBrowser()
if browser is not None:
url = browser.url()
if url.isValid():
host = url.host()
else:
host = ""
res = self.__matchDomain(cookieDomain, host)
if not res:
return True
if self.__filterTrackingCookies and cookie.name().startsWith(b"__utm"):
return True
return False
def save(self):
"""
Public method to save the download settings.
"""
if not self.__loaded:
return
Preferences.setWebBrowser("DownloadManagerSize", self.size())
Preferences.setWebBrowser("DownloadManagerPosition", self.pos())
if self.removePolicy() == DownloadManager.RemoveExit:
return
from WebBrowser.WebBrowserWindow import WebBrowserWindow
if WebBrowserWindow.isPrivate():
return
downloads = []
for download in self.__downloads:
downloads.append(download.getData())
Preferences.setWebBrowser("DownloadManagerDownloads", downloads)
def isEnabled(cls):
"""
Class method to check, if the web inspector is enabled.
@return flag indicating the enabled state
@rtype bool
"""
if qVersionTuple() < (5, 11, 0):
if not os.getenv("QTWEBENGINE_REMOTE_DEBUGGING"):
return False
from WebBrowser.WebBrowserWindow import WebBrowserWindow
if not WebBrowserWindow.webSettings().testAttribute(
QWebEngineSettings.JavascriptEnabled):
return False
if qVersionTuple() < (5, 11, 0):
return Preferences.getWebBrowser("WebInspectorEnabled")
else:
return True
def __init__(self, title, url=None, parent=None):
"""
Constructor
@param title title of the menu (string)
@param url URL to set user agent for (QUrl)
@param parent reference to the parent widget (QWidget)
"""
super(UserAgentMenu, self).__init__(title, parent)
self.__manager = None
self.__url = url
if self.__url:
if self.__url.isValid():
from WebBrowser.WebBrowserWindow import WebBrowserWindow
self.__manager = WebBrowserWindow.userAgentsManager()
else:
self.__url = None
self.aboutToShow.connect(self.__populateMenu)
def updateNow(self):
"""
Public method to update the subscription immediately.
"""
if self.__downloading is not None:
return
if not self.location().isValid():
return
if self.location().scheme() == "file":
self.__lastUpdate = QDateTime.currentDateTime()
self.__loadRules()
return
from WebBrowser.WebBrowserWindow import WebBrowserWindow
reply = WebBrowserWindow.networkManager().get(
QNetworkRequest(self.location()))
reply.finished.connect(
lambda: self.__rulesDownloaded(reply))
self.__downloading = reply
def on_imagesTree_currentItemChanged(self, current, previous):
"""
Private slot to show a preview of the selected image.
@param current current image entry (QTreeWidgetItem)
@param previous old current entry (QTreeWidgetItem)
"""
if current is None:
return
imageUrl = QUrl(current.text(1))
if imageUrl.isRelative():
imageUrl = self.__baseUrl.resolved(imageUrl)
pixmap = QPixmap()
loading = False
if imageUrl.scheme() == "data":
encodedUrl = current.text(1).encode("utf-8")
imageData = encodedUrl[encodedUrl.find(b",") + 1:]
pixmap = WebBrowserTools.pixmapFromByteArray(imageData)
elif imageUrl.scheme() == "file":
pixmap = QPixmap(imageUrl.toLocalFile())
elif imageUrl.scheme() == "qrc":
pixmap = QPixmap(imageUrl.toString()[3:])
else:
if self.__imageReply is not None:
self.__imageReply.deleteLater()
self.__imageReply = None
from WebBrowser.WebBrowserWindow import WebBrowserWindow
self.__imageReply = WebBrowserWindow.networkManager().get(
QNetworkRequest(imageUrl))
self.__imageReply.finished.connect(self.__imageReplyFinished)
loading = True
self.__showLoadingText()
if not loading:
self.__showPixmap(pixmap)
def __init__(self, parent=None):
"""
Constructor
@param parent reference to the parent widget
@type QWidget
"""
super(DownloadManagerButton, self).__init__(parent)
self.__manager = WebBrowserWindow.downloadManager()
self.setObjectName("navigation_download_manager_button")
self.setIcon(UI.PixmapCache.getIcon("downloads.png"))
self.setToolTip(self.tr("Open Download Manager"))
self.setToolButtonStyle(Qt.ToolButtonIconOnly)
self.setFocusPolicy(Qt.NoFocus)
self.setAutoRaise(True)
self.clicked.connect(self.__buttonClicked)
self.__manager.downloadsCountChanged.connect(self.__updateState)
self.__updateState()
def __init__(self, url, manager, mode):
"""
Constructor
@param url URL to download script from
@type QUrl
@param manager reference to the GreaseMonkey manager
@type GreaseMonkeyManager
@param mode download mode
@type int (one of DownloadMainScript, DownloadRequireScript)
"""
super(GreaseMonkeyDownloader, self).__init__()
self.__manager = manager
self.__reply = WebBrowserWindow.networkManager().get(
QNetworkRequest(url))
if mode == GreaseMonkeyDownloader.DownloadMainScript:
self.__reply.finished.connect(self.__scriptDownloaded)
else:
self.__reply.finished.connect(self.__requireDownloaded)
self.__fileName = ""
def prePopulated(self):
"""
Public method to add any actions before the tree.
@return flag indicating if any actions were added (boolean)
"""
from WebBrowser.WebBrowserWindow import WebBrowserWindow
manager = WebBrowserWindow.bookmarksManager()
self.setModel(manager.bookmarksModel())
self.setRootIndex(manager.bookmarksModel().nodeIndex(manager.menu()))
# initial actions
for act in self.__initialActions:
if act == "--SEPARATOR--":
self.addSeparator()
else:
self.addAction(act)
if len(self.__initialActions) != 0:
self.addSeparator()
self.createMenu(manager.bookmarksModel().nodeIndex(manager.toolbar()),
1, self)
return True
