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