def test_invalid_url_error(urlutils_message_mock, url, valid, has_err_string): """Test invalid_url_error(). Args: url: The URL to check. valid: Whether the QUrl is valid (isValid() == True). has_err_string: Whether the QUrl is expected to have errorString set. """ qurl = QUrl(url) assert qurl.isValid() == valid if valid: with pytest.raises(ValueError): urlutils.invalid_url_error(0, qurl, '') assert not urlutils_message_mock.messages else: assert bool(qurl.errorString()) == has_err_string urlutils.invalid_url_error(0, qurl, 'frozzle') msg = urlutils_message_mock.getmsg(urlutils_message_mock.Level.error) if has_err_string: expected_text = ("Trying to frozzle with invalid URL - " + qurl.errorString()) else: expected_text = "Trying to frozzle with invalid URL" assert msg.text == expected_text
def resolve_url(self, baseurl): """Resolve the URL in the element's src/href attribute. Args: baseurl: The URL to base relative URLs on as QUrl. Return: A QUrl with the absolute URL, or None. """ if baseurl.isRelative(): raise ValueError("Need an absolute base URL!") for attr in ['href', 'src']: if attr in self: text = self[attr].strip() break else: return None url = QUrl(text) if not url.isValid(): return None if url.isRelative(): url = baseurl.resolved(url) qtutils.ensure_valid(url) return url
def exportProfile(self, instance_id: str, file_url: QUrl, file_type: str) -> None: if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return self._container_registry.exportProfile(instance_id, path, file_type)
def _is_blocked(self, request_url: QUrl, first_party_url: QUrl = None) -> bool: """Check whether the given request is blocked.""" if not self.enabled: return False if first_party_url is not None and not first_party_url.isValid(): first_party_url = None qtutils.ensure_valid(request_url) if not config.get("content.blocking.enabled", url=first_party_url): return False if blockutils.is_whitelisted_url(request_url): return False host = request_url.host() if config.get("content.blocking.hosts.block_subdomains"): return any( hostname in self._blocked_hosts or hostname in self._config_blocked_hosts for hostname in urlutils.widened_hostnames(host) ) else: return ( host in self._blocked_hosts or host in self._config_blocked_hosts )
def test_data_url(): """Test data_url() which can be used from templates.""" data = jinja.render('test3.html') print(data) url = QUrl(data) assert url.isValid() assert data == 'data:text/plain;base64,Zm9v' # 'foo'
def blocklist_to_url(filename): """Get an example.com-URL with the given filename as path.""" assert not os.path.isabs(filename), filename url = QUrl('http://example.com/') url.setPath('/' + filename) assert url.isValid(), url.errorString() return url
def test_invalid_url_error(message_mock, caplog, url, valid, has_err_string): """Test invalid_url_error(). Args: url: The URL to check. valid: Whether the QUrl is valid (isValid() == True). has_err_string: Whether the QUrl is expected to have errorString set. """ qurl = QUrl(url) assert qurl.isValid() == valid if valid: with pytest.raises(ValueError): urlutils.invalid_url_error(qurl, '') assert not message_mock.messages else: assert bool(qurl.errorString()) == has_err_string with caplog.at_level(logging.ERROR): urlutils.invalid_url_error(qurl, 'frozzle') msg = message_mock.getmsg(usertypes.MessageLevel.error) if has_err_string: expected_text = ("Trying to frozzle with invalid URL - " + qurl.errorString()) else: expected_text = "Trying to frozzle with invalid URL" assert msg.text == expected_text
def from_str(cls, line): """Parse a history line like '12345 http://example.com title'.""" data = line.split(maxsplit=2) if len(data) == 2: atime, url = data title = "" elif len(data) == 3: atime, url, title = data else: raise ValueError("2 or 3 fields expected") url = QUrl(url) if not url.isValid(): raise ValueError("Invalid URL: {}".format(url.errorString())) if atime.startswith('\0'): log.init.debug( "Removing NUL bytes from entry {!r} - see " "https://github.com/The-Compiler/qutebrowser/issues/" "670".format(data)) atime = atime.lstrip('\0') if '-' in atime: atime, flags = atime.split('-') else: flags = '' if not set(flags).issubset('r'): raise ValueError("Invalid flags {!r}".format(flags)) redirect = 'r' in flags return cls(atime, url, title, redirect=redirect)
def resolve_url(self, baseurl: QUrl) -> typing.Optional[QUrl]: """Resolve the URL in the element's src/href attribute. Args: baseurl: The URL to base relative URLs on as QUrl. Return: A QUrl with the absolute URL, or None. """ if baseurl.isRelative(): raise ValueError("Need an absolute base URL!") for attr in ['href', 'src']: if attr in self: text = self[attr].strip() break else: return None url = QUrl(text) if not url.isValid(): return None if url.isRelative(): url = baseurl.resolved(url) qtutils.ensure_valid(url) return url
def __init__(self, qml): app = QGuiApplication(sys.argv) model = QmlModel() model.register() qmlUrl = QUrl(qml) assert qmlUrl.isValid() print(qmlUrl.path()) # assert qmlUrl.isLocalFile() """ Create an engine a reference to the window? window = QuickWindowFactory().create(qmlUrl=qmlUrl) window.show() # visible """ engine = QQmlApplicationEngine() """ Need this if no stdio, i.e. Android, OSX, iOS. OW, qWarnings to stdio. engine.warnings.connect(self.errors) """ engine.load(qmlUrl) engine.quit.connect(app.quit) app.exec_() # !!! C exec => Python exec_ print("Application returned")
def importProfile(self, file_url: QUrl) -> Dict[str, str]: if not file_url.isValid(): return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} path = file_url.toLocalFile() if not path: return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} return self._container_registry.importProfile(path)
def contextMenuEvent(self, evt): """ Protected method handling context menu events. @param evt reference to the context menu event (QContextMenuEvent) """ point = evt.globalPos() if self.__browser: point = self.__browser.mapFromGlobal(point) if not self.__browser.rect().contains(point, True): return link = QUrl(self.__browser.anchorAt(point)) else: point = self.__result.mapFromGlobal(point) link = self.__result.linkAt(point) if link.isEmpty() or not link.isValid(): return menu = QMenu() curTab = menu.addAction(self.tr("Open Link")) newTab = menu.addAction(self.tr("Open Link in New Tab")) menu.move(evt.globalPos()) act = menu.exec_() if act == curTab: self.linkActivated.emit(link) elif act == newTab: self.__mw.newTab(link)
def wait_for_load_finished_url(self, url, *, timeout=None, load_status='success'): """Wait until a URL has finished loading.""" __tracebackhide__ = ( lambda e: e.errisinstance(testprocess.WaitForTimeout)) if timeout is None: if 'CI' in os.environ: timeout = 15000 else: timeout = 5000 # We really need the same representation that the webview uses in its # __repr__ qurl = QUrl(url) if not qurl.isValid(): raise ValueError("Invalid URL {}: {}".format( url, qurl.errorString())) url = utils.elide(qurl.toDisplayString(QUrl.EncodeUnicode), 100) assert url pattern = re.compile( r"(load status for <qutebrowser\.browser\..* " r"tab_id=\d+ url='{url}/?'>: LoadStatus\.{load_status}|fetch: " r"PyQt5\.QtCore\.QUrl\('{url}'\) -> .*)".format( load_status=re.escape(load_status), url=re.escape(url))) try: self.wait_for(message=pattern, timeout=timeout) except testprocess.WaitForTimeout: raise testprocess.WaitForTimeout("Timed out while waiting for {} " "to be loaded".format(url))
def acceptNavigationRequest(self, url: QUrl, typ: QWebEnginePage.NavigationType, is_main_frame: bool): """Override acceptNavigationRequest to handle clicked links. Setting linkDelegationPolicy to DelegateAllLinks and using a slot bound to linkClicked won't work correctly, because when in a frameset, we have no idea in which frame the link should be opened. Checks if it should open it in a tab (middle-click or control) or not, and then conditionally opens the URL. Opening it in a new tab/window is handled in the slot connected to link_clicked. """ target = self._tabdata.combined_target() log.webview.debug("navigation request: url {}, type {}, " "target {}, is_main_frame {}".format( url.toDisplayString(), debug.qenum_key(QWebEnginePage, typ), target, is_main_frame)) if typ != QWebEnginePage.NavigationTypeLinkClicked: return True self.link_clicked.emit(url) return url.isValid() and target == usertypes.ClickTarget.normal
def wait_for_load_finished_url(self, url, *, timeout=None, load_status='success'): """Wait until a URL has finished loading.""" __tracebackhide__ = (lambda e: e.errisinstance( testprocess.WaitForTimeout)) if timeout is None: if 'CI' in os.environ: timeout = 15000 else: timeout = 5000 # We really need the same representation that the webview uses in its # __repr__ qurl = QUrl(url) if not qurl.isValid(): raise ValueError("Invalid URL {}: {}".format(url, qurl.errorString())) url = utils.elide(qurl.toDisplayString(QUrl.EncodeUnicode), 100) assert url pattern = re.compile( r"(load status for <qutebrowser\.browser\..* " r"tab_id=\d+ url='{url}/?'>: LoadStatus\.{load_status}|fetch: " r"PyQt5\.QtCore\.QUrl\('{url}'\) -> .*)".format( load_status=re.escape(load_status), url=re.escape(url))) try: self.wait_for(message=pattern, timeout=timeout) except testprocess.WaitForTimeout: raise testprocess.WaitForTimeout("Timed out while waiting for {} " "to be loaded".format(url))
def readLocalFile(self, file: QUrl, add_to_recent_files_hint: bool = True) -> None: if not file.isValid(): return if add_to_recent_files_hint: self._add_to_recent_files_hints.append(file) self._readLocalFile(file)
def test_strip(self, url_suffix): url_base = 'https://example.com/test' url = QUrl(url_base + url_suffix) assert url.isValid() stripped = navigate.strip(url, count=1) assert stripped.isValid() assert stripped == QUrl(url_base)
def setUrl(self, url): """ Public slot to set the xmlrpc handler URL. @param url xmlrpc handler URL (string or QUrl) """ url = QUrl(url) if url.isValid(): self.__request.setUrl(url)
def exportQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup", file_url: QUrl, file_type: str) -> None: if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return container_list = [n.getContainer() for n in quality_changes_group.getAllNodes() if n.getContainer() is not None] self._container_registry.exportQualityProfile(container_list, path, file_type)
def importProfile(self, file_url: QUrl) -> Dict[str, str]: """Import single profile, file_url does not have to end with curaprofile""" if not file_url.isValid(): return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} path = file_url.toLocalFile() if not path: return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)} return cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().importProfile(path)
def is_special_url(url: QUrl) -> bool: """Return True if url is an about:... or other special URL. Args: url: The URL as QUrl. """ if not url.isValid(): return False special_schemes = ('about', 'qute', 'file') return url.scheme() in special_schemes
def main(): import sys app = QApplication(sys.argv) QQuickWindow.setDefaultAlphaBuffer(True) QCoreApplication.setApplicationName("Photosurface") QCoreApplication.setOrganizationName("QtProject") QCoreApplication.setApplicationVersion(QT_VERSION_STR) parser = QCommandLineParser() parser.setApplicationDescription("Qt Quick Demo - Photo Surface") parser.addHelpOption() parser.addVersionOption() parser.addPositionalArgument("directory", "The image directory or URL to show.") parser.process(app) initialUrl = QUrl() if parser.positionalArguments(): initialUrl = QUrl.fromUserInput(parser.positionalArguments()[0], QDir.currentPath(), QUrl.AssumeLocalFile) if not initialUrl.isValid(): print( 'Invalid argument: "', parser.positionalArguments()[0], '": ', initialUrl.errorString(), ) sys.exit(1) nameFilters = imageNameFilters() engine = QQmlApplicationEngine() context: QQmlContext = engine.rootContext() picturesLocationUrl = QUrl.fromLocalFile(QDir.homePath()) picturesLocations = QStandardPaths.standardLocations( QStandardPaths.PicturesLocation) if picturesLocations: picturesLocationUrl = QUrl.fromLocalFile(picturesLocations[0]) if not initialUrl and QDir(picturesLocations[0]).entryInfoList( nameFilters, QDir.Files): initialUrl = picturesLocationUrl context.setContextProperty("contextPicturesLocation", picturesLocationUrl) context.setContextProperty("contextInitialUrl", initialUrl) context.setContextProperty("contextImageNameFilters", nameFilters) engine.load(QUrl("qrc:///photosurface.qml")) if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def onItemClicked(self, idx): item = self.model.itemFromIndex(idx) if isinstance(item, AtomFeedEntryItem): url = QUrl(item.entry.id) if url.isValid(): self.webView.load(url) self.model.markEntryAsRead(item) item.setFont(self.fontRead) item.parent().updateTitle()
def validate(self, value): if not value: if self._none_ok: return else: raise configexc.ValidationError(value, "may not be empty!") if "{}" not in value: raise configexc.ValidationError(value, 'must contain "{}"') url = QUrl(value.replace("{}", "foobar")) if not url.isValid(): raise configexc.ValidationError(value, "invalid url, {}".format(url.errorString()))
def test_hypothesis(self, source): scheme = 'javascript:' url = QUrl(scheme + urllib.parse.quote(source)) hypothesis.assume(url.isValid()) try: parsed = urlutils.parse_javascript_url(url) except urlutils.Error: pass else: assert parsed == source
def validate(self, value): if not value: if self._none_ok: return else: raise ValidationError(value, "may not be empty!") if '{}' not in value: raise ValidationError(value, "must contain \"{}\"") url = QUrl(value.replace('{}', 'foobar')) if not url.isValid(): raise ValidationError(value, "invalid url, {}".format(url.errorString()))
def invalid_url_error(url: QUrl, action: str) -> None: """Display an error message for a URL. Args: action: The action which was interrupted by the error. """ if url.isValid(): raise ValueError("Calling invalid_url_error with valid URL {}".format( url.toDisplayString())) errstring = get_errstring(url, "Trying to {} with invalid URL".format(action)) message.error(errstring)
def validate(self, value): if not value: if self._none_ok: return else: raise configexc.ValidationError(value, "may not be empty!") if '{}' not in value: raise configexc.ValidationError(value, "must contain \"{}\"") url = QUrl(value.replace('{}', 'foobar')) if not url.isValid(): raise configexc.ValidationError(value, "invalid url, {}".format( url.errorString()))
def qmlFilenameToQUrl(self, qmlSubpath): root_url = 'qrc:' if self._root.startswith(':') else self._root print("root_url: ", root_url) #url = QUrl(root_url + '/' + self._appPackageName + qmlSubpath) url = QUrl(root_url + qmlSubpath) print("urlToQMLResource", url) assert url.isValid() #print(url.path()) #assert url.isLocalFile() return url
def _has_explicit_scheme(url: QUrl): """Check if a url has an explicit scheme given. Args: url: The URL as QUrl. """ # Note that generic URI syntax actually would allow a second colon # after the scheme delimiter. Since we don't know of any URIs # using this and want to support e.g. searching for scoped C++ # symbols, we treat this as not a URI anyways. return (url.isValid() and url.scheme() and (url.host() or url.path()) and " " not in url.path() and not url.path().startswith(":"))
def test_whitespace_hosts(host): """Test that whitespace dot hosts are invalid. This is a deviation from Chromium. """ template = 'https://{}/*' url = QUrl(template.format(host)) assert not url.isValid() with pytest.raises(urlmatch.ParseError, match='Invalid host|Pattern without host'): urlmatch.UrlPattern(template.format(host))
def exportQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup", file_url: QUrl, file_type: str) -> None: if not file_url.isValid(): return path = file_url.toLocalFile() if not path: return container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry() container_list = [cast(InstanceContainer, container_registry.findContainers(id = quality_changes_group.metadata_for_global["id"])[0])] # type: List[InstanceContainer] for metadata in quality_changes_group.metadata_per_extruder.values(): container_list.append(cast(InstanceContainer, container_registry.findContainers(id = metadata["id"])[0])) cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().exportQualityProfile(container_list, path, file_type)
def get(name): """Get the URL of the quickmark named name as a QUrl.""" if name not in marks: raise cmdexc.CommandError( "Quickmark '{}' does not exist!".format(name)) urlstr = marks[name] url = QUrl(urlstr) if not url.isValid(): raise cmdexc.CommandError( "Invalid URL for quickmark {}: {} ({})".format(name, urlstr, url.errorString())) return url
def addToPlaylist(self, fileNames): for name in fileNames: fileInfo = QFileInfo(name) if fileInfo.exists(): url = QUrl.fromLocalFile(fileInfo.absoluteFilePath()) if fileInfo.suffix().lower() == 'm3u': self.playlist.load(url) else: self.playlist.addMedia(QMediaContent(url)) else: url = QUrl(name) if url.isValid(): self.playlist.addMedia(QMediaContent(url))
def openOnStart(self, name): fileInfo = QFileInfo(name) if fileInfo.exists(): url = QUrl.fromLocalFile(fileInfo.absoluteFilePath()) if fileInfo.suffix().lower() == 'm3u': self.playlist.load(url) else: self.playlist.addMedia(QMediaContent(url)) else: url = QUrl(name) if url.isValid(): self.playlist.addMedia(QMediaContent(url)) print("added Files to playlist")
def __init__(self, connections=None, parent=None): """ Constructor @param connections list of database connections to add (list of strings) @param parent reference to the parent widget (QWidget) """ super(SqlBrowser, self).__init__(parent) self.setObjectName("SqlBrowser") if connections is None: connections = [] self.setWindowTitle(self.tr("SQL Browser")) self.setWindowIcon(UI.PixmapCache.getIcon("eric.png")) self.setStyle(Preferences.getUI("Style"), Preferences.getUI("StyleSheet")) from .SqlBrowserWidget import SqlBrowserWidget self.__browser = SqlBrowserWidget(self) self.setCentralWidget(self.__browser) self.__browser.statusMessage.connect(self.statusBar().showMessage) self.__initActions() self.__initMenus() self.__initToolbars() self.resize(self.__browser.size()) self.__warnings = [] for connection in connections: url = QUrl(connection, QUrl.TolerantMode) if not url.isValid(): self.__warnings.append( self.tr("Invalid URL: {0}").format(connection)) continue err = self.__browser.addConnection(url.scheme(), url.path(), url.userName(), url.password(), url.host(), url.port(-1)) if err.type() != QSqlError.NoError: self.__warnings.append( self.tr("Unable to open connection: {0}".format( err.text()))) QTimer.singleShot(0, self.__uiStartUp)
def _is_blocked(self, request_url: QUrl, first_party_url: QUrl = None) -> bool: """Check whether the given request is blocked.""" if first_party_url is not None and not first_party_url.isValid(): first_party_url = None if not config.get('content.host_blocking.enabled', url=first_party_url): return False host = request_url.host() return ((host in self._blocked_hosts or host in self._config_blocked_hosts) and not _is_whitelisted_url(request_url))
def validate(self, value): self._basic_validation(value) if not value: return elif value in self.valid_values: return url = QUrl(value) if not url.isValid(): raise configexc.ValidationError(value, "invalid url, {}".format( url.errorString())) elif url.scheme() not in self.PROXY_TYPES: raise configexc.ValidationError(value, "must be a proxy URL " "(http://... or socks://...) or " "system/none!")
def quickmark_load(self, name, tab=False, bg=False): """Load a quickmark. Args: name: The name of the quickmark to load. tab: Load the quickmark in a new tab. bg: Load the quickmark in a new background tab. """ urlstr = quickmarks.get(name) url = QUrl(urlstr) if not url.isValid(): raise cmdexc.CommandError("Invalid URL {} ({})".format( urlstr, url.errorString())) self._open(url, tab, bg)
def validate(self, value): if not value: if self._none_ok: return else: raise ValidationError(value, "may not be empty!") if value in self.valid_values: return url = QUrl(value) if not url.isValid(): raise ValidationError(value, "invalid url, {}".format( url.errorString())) elif url.scheme() not in self.PROXY_TYPES: raise ValidationError(value, "must be a proxy URL (http://... or " "socks://...) or system/none!")
def validate(self, value): self._basic_validation(value) if not value: return elif '{}' not in value: raise configexc.ValidationError(value, "must contain \"{}\"") try: value.format("") except KeyError: raise configexc.ValidationError( value, "may not contain {...} (use {{ and }} for literal {/})") url = QUrl(value.replace('{}', 'foobar')) if not url.isValid(): raise configexc.ValidationError(value, "invalid url, {}".format( url.errorString()))
def test_resource_url(): """Test resource_url() which can be used from templates.""" data = jinja.render('test2.html') print(data) url = QUrl(data) assert url.isValid() assert url.scheme() == 'file' path = url.path() if os.name == "nt": path = path.lstrip('/') path = path.replace('/', os.sep) with open(path, 'r', encoding='utf-8') as f: assert f.read().splitlines()[0] == "Hello World!"
def __init__(self, connections=[], parent=None): """ Constructor @param connections list of database connections to add (list of strings) @param parent reference to the parent widget (QWidget) """ super(SqlBrowser, self).__init__(parent) self.setObjectName("SqlBrowser") self.setWindowTitle(self.tr("SQL Browser")) self.setWindowIcon(UI.PixmapCache.getIcon("eric.png")) self.setStyle(Preferences.getUI("Style"), Preferences.getUI("StyleSheet")) from .SqlBrowserWidget import SqlBrowserWidget self.__browser = SqlBrowserWidget(self) self.setCentralWidget(self.__browser) self.__browser.statusMessage.connect(self.statusBar().showMessage) self.__initActions() self.__initMenus() self.__initToolbars() self.resize(self.__browser.size()) self.__warnings = [] for connection in connections: url = QUrl(connection, QUrl.TolerantMode) if not url.isValid(): self.__warnings.append( self.tr("Invalid URL: {0}").format(connection)) continue err = self.__browser.addConnection(url.scheme(), url.path(), url.userName(), url.password(), url.host(), url.port(-1)) if err.type() != QSqlError.NoError: self.__warnings.append( self.tr("Unable to open connection: {0}".format( err.text()))) QTimer.singleShot(0, self.__uiStartUp)
def test_resource_url(): """Test resource_url() which can be used from templates.""" template = jinja.env.get_template("test2.html") data = template.render() # pylint: disable=no-member print(data) url = QUrl(data) assert url.isValid() assert url.scheme() == "file" path = url.path() if os.name == "nt": path = path.lstrip("/") path = path.replace("/", os.sep) with open(path, "r", encoding="utf-8") as f: assert f.read().splitlines()[0] == "Hello World!"
def __addFeed(self): """ Private slot to add a RSS feed. """ button = self.sender() urlString = button.feed[1] url = QUrl(urlString) if not url.host(): if not urlString.startswith("/"): urlString = "/" + urlString urlString = self.__browser.url().host() + urlString tmpUrl = QUrl(urlString) if not tmpUrl.scheme(): urlString = "http://" + urlString tmpUrl = QUrl(urlString) if not tmpUrl.scheme() or not tmpUrl.host(): return if not url.isValid(): return if button.feed[0]: title = button.feed[0] else: title = self.__browser.url().host() import Helpviewer.HelpWindow feedsManager = Helpviewer.HelpWindow.HelpWindow.feedsManager() if feedsManager.addFeed(urlString, title, self.__browser.icon()): if Helpviewer.HelpWindow.HelpWindow.notificationsEnabled(): Helpviewer.HelpWindow.HelpWindow.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 set_hover_url(self, link): """Setter to be used as a Qt slot. Saves old shown URL in self._old_url and restores it later if a link is "un-hovered" when it gets called with empty parameters. Args: link: The link which was hovered (string) """ if link: qurl = QUrl(link) if qurl.isValid(): self._hover_url = qurl.toDisplayString() else: self._hover_url = link else: self._hover_url = None self._update_url()
def set_hover_url(self, link): """Setter to be used as a Qt slot. Saves old shown URL in self._old_url and restores it later if a link is "un-hovered" when it gets called with empty parameters. Args: link: The link which was hovered (string) """ if link: qurl = QUrl(link) if qurl.isValid(): self._hover_url = urlutils.safe_display_string(qurl) else: self._hover_url = '(invalid URL!) {}'.format(link) else: self._hover_url = None self._update_url()
def acceptNavigationRequest(self, url: QUrl, typ: QWebEnginePage.NavigationType, is_main_frame: bool): """Override acceptNavigationRequest to handle clicked links. This only show an error on invalid links - everything else is handled in createWindow. """ log.webview.debug("navigation request: url {}, type {}, is_main_frame " "{}".format(url.toDisplayString(), debug.qenum_key(QWebEnginePage, typ), is_main_frame)) if (typ == QWebEnginePage.NavigationTypeLinkClicked and not url.isValid()): msg = urlutils.get_errstring(url, "Invalid link clicked") message.error(msg) return False return True