def new_ephemeral(window):
"""
New ephemeral webview
@param window as Window
"""
view = WebKit2.WebView.new_with_context(El().ephemeral_context)
view.__class__ = WebViewMeta
view.__init(None, window)
return view
def _on_map(self, webview):
"""
Connect all signals
@param webview as WebView
"""
page_id = webview.get_page_id()
El().helper.connect(
None, lambda a, b, c, d, e, f: WebViewDBusSignals.__on_signal(
self, e, f), page_id)
def __on_js_timeout(self, webview):
"""
Tell webpage to update credentials
@param webview as WebView
"""
self.__js_timeout_id = None
page_id = webview.get_page_id()
El().helper.call("SetCredentials", GLib.Variant("(i)", (page_id, )),
None, page_id)
def __on_image_change_state(self, action, param):
"""
Update image block state
@param action as Gio.SimpleAction
@param param as GLib.Variant
"""
action.set_state(param)
El().settings.set_value("imgblock", param)
self.__window.container.current.webview.reload()
def _on_tls_button_clicked(self, button):
"""
Do not accept TLS for this site by default
@param button as Gtk.Button
"""
button.hide()
uri = self.__window.container.current.webview.uri
El().websettings.set_accept_tls(uri, False)
self.__window.container.close_view(self.__window.container.current)
def __on_window_state_event(self, widget, event):
"""
Save maximised state
"""
size = widget.get_size()
self.toolbar.title.set_width(size[0] / 3)
El().settings.set_boolean(
'window-maximized', 'GDK_WINDOW_STATE_MAXIMIZED'
in event.new_window_state.value_names)
def _on_default_zoom_button_clicked(self, button):
"""
Restore default zoom level
@param button as Gtk.Button
"""
webview = self.__window.container.current.webview
El().websettings.set_zoom(100, webview.uri)
webview.update_zoom_level()
button.set_label("100 %")
def _on_close_button_press(self, eventbox, event):
"""
Remove tag
@param eventbox as Gtk.EventBox
@param event as Gtk.Event
"""
tag_title = self.__label.get_text()
El().bookmarks.del_tag(tag_title, True)
self.destroy()
def _on_selection_changed(self, chooser):
"""
Save uri
@chooser as Gtk.FileChooserButton
"""
uri = chooser.get_uri()
if uri is None:
uri = ""
El().settings.set_value("download-uri", GLib.Variant("s", uri))
def __on_file_chooser_response(self, dialog, response_id):
"""
Import file
@param dialog as GtkFileChooserDialog
@param response_id as int
"""
if response_id == Gtk.ResponseType.OK:
path = dialog.get_filename()
El().bookmarks.import_html(path)
def __on_accept_scheme(self, request):
"""
Accept certificate for uri
@param request as WebKit2.URISchemeRequest
"""
view = request.get_web_view()
if view.bad_tls is None:
return
request_uri = request.get_uri()
parsed = urlparse(request_uri)
uri = request_uri.replace("accept://", "https://")
if not El().websettings.get_accept_tls(uri):
El().websettings.set_accept_tls(uri, True)
self.__context.allow_tls_certificate_for_host(
view.bad_tls,
# Remove port
parsed.netloc.split(":")[0])
view.load_uri(uri)
def __on_message_popover_ok(self, name, search, suggest, encoding):
"""
Save engine
@param name as str
@param uri as str
@param suggest_uri as str
@param encoding as str
"""
# Save engines
engines = El().search.engines
parsed = urlparse(search)
uri = "%s://%s" % (parsed.scheme, parsed.netloc)
engines[name] = [uri,
search.replace("{searchTerms}", "%s"),
suggest.replace("{searchTerms}", "%s"),
encoding,
""]
El().search.save_engines(engines)
def __populate(self):
"""
Populate profile
"""
# Load user profiles
try:
self.__add_profiles(El().profiles)
except Exception as e:
print("DialogSearchEngine::__populate():", e)
def __on_action_clicked(self, action, variant, item):
"""
Load history
@param Gio.SimpleAction
@param GVariant
@param item as WebKit2.BackForwardListItem
"""
El().active_window.\
container.current.webview.go_to_back_forward_list_item(item)
def load_uri(self, uri):
"""
Load uri
@param uri as str
"""
self._error = False
# Allow profile switching
self.__previous_uri = ""
# If not an URI, start a search
parsed = urlparse(uri)
is_uri = parsed.scheme in [
"about", "http", "https", "file", "populars"
]
if not is_uri and\
not uri.startswith("/") and\
El().search.is_search(uri):
uri = El().search.get_search_uri(uri)
parsed = urlparse(uri)
if uri == "about:blank":
WebKit2.WebView.load_plain_text(self, "")
# We are not a ftp browser, fall back to env
elif parsed.scheme == "ftp":
argv = [get_ftp_cmd(), uri, None]
GLib.spawn_sync(None, argv, None, GLib.SpawnFlags.SEARCH_PATH,
None)
else:
if uri.startswith("/"):
uri = "file://" + uri
elif parsed.scheme == "javascript":
# To bypass popup blocker
self._last_click_time = time()
uri = GLib.uri_unescape_string(uri, None)
self.run_javascript(uri.replace("javascript:", ""), None, None)
elif parsed.scheme not in [
"http", "https", "file", "populars", "accept"
]:
uri = "http://" + uri
# Reset bad tls certificate
if parsed.scheme != "accept":
self.reset_bad_tls()
self.__insecure_content_detected = False
# Prevent cookies access on profile switching
self.stop_loading()
GLib.idle_add(WebKit2.WebView.load_uri, self, uri)
def __init__(self, item):
"""
Init row
@param item as Item
"""
self.__item = item
self.__eventbox = None
Gtk.ListBoxRow.__init__(self)
item_id = item.get_property("id")
uri = item.get_property("uri")
title = item.get_property("title")
grid = Gtk.Grid()
grid.set_column_spacing(10)
grid.set_hexpand(True)
grid.set_property('valign', Gtk.Align.CENTER)
if item_id == BookmarksType.URI:
surface = El().art.get_artwork(uri, "favicon",
self.get_scale_factor(),
ArtSize.FAVICON, ArtSize.FAVICON)
favicon = Gtk.Image.new_from_surface(surface)
if surface is None:
favicon.set_from_icon_name("applications-internet",
Gtk.IconSize.MENU)
else:
del surface
elif item_id == BookmarksType.SEARCH:
favicon = Gtk.Image.new_from_icon_name("system-search-symbolic",
Gtk.IconSize.MENU)
else:
if item_id == BookmarksType.POPULARS:
icon_name = "starred-symbolic"
elif item_id == BookmarksType.RECENTS:
icon_name = "document-open-recent-symbolic"
else:
icon_name = "folder-symbolic"
favicon = Gtk.Image.new_from_icon_name(icon_name,
Gtk.IconSize.MENU)
favicon.show()
title = Gtk.Label.new(title)
title.set_ellipsize(Pango.EllipsizeMode.END)
title.set_property('halign', Gtk.Align.START)
title.set_hexpand(True)
uri = Gtk.Label.new(item.get_property("uri"))
uri.set_ellipsize(Pango.EllipsizeMode.END)
uri.set_property('halign', Gtk.Align.END)
uri.get_style_context().add_class('dim-label')
uri.set_max_width_chars(40)
grid.add(favicon)
grid.add(title)
grid.add(uri)
grid.show_all()
self.__eventbox = Gtk.EventBox()
self.__eventbox.add(grid)
self.__eventbox.set_size_request(-1, 30)
self.__eventbox.show()
self.add(self.__eventbox)
def __init__(self, page_id, window):
"""
Init menu
@param page_id as int
@param window as Window
"""
Gio.Menu.__init__(self)
self.__window = window
self.__actions = []
El().helper.call("GetVideos", page_id, None, self.__on_get_videos)
def __on_delete_clicked(self, button):
"""
Delete item from cookies
@param button as Gtk.Button
"""
sql = sqlite3.connect(El().cookies_path, 600.0)
sql.execute("DELETE FROM moz_cookies\
WHERE host=?", (self.__item.get_property("host"),))
sql.commit()
GLib.idle_add(self.destroy)
def _on_remove_tags_clicked(self, button):
"""
Remove tag
@param button as Gtk.Button
"""
El().bookmarks.thread_lock.acquire()
if button.get_label() == _("Finished"):
removable = False
button.set_label(_("Remove"))
self.__rename_tag_button.show()
button.get_style_context().remove_class("suggested-action")
else:
removable = True
button.set_label(_("Finished"))
self.__rename_tag_button.hide()
button.get_style_context().add_class("suggested-action")
for child in self.__flowbox.get_children():
child.set_removable(removable)
El().bookmarks.thread_lock.release()
def __on_uri_changed(self, webview, uri):
"""
Update title bar
@param webview as WebView
@param uri as str
"""
if webview.get_mapped():
accept_tls = El().websettings.get_accept_tls(uri)
self._window.toolbar.end.show_tls_button(accept_tls)
self._window.toolbar.title.set_uri(uri)
def __on_resource_load_finished(self, resource):
"""
Restore cookie storage default behaviour
@param resource as WebKit2.WebResource
"""
self.__google_fix_count -= 1
if self.__google_fix_count == 0:
cookie_manager = self.get_context().get_cookie_manager()
storage = El().settings.get_enum("cookie-storage")
cookie_manager.set_accept_policy(storage)
def __get_forms(self, forms, page_id, request):
"""
Read request for authentification
@param forms as [str]
@param page_id as int
@param request as WebKit2.FormSubmissionRequest
"""
El().helper.call("GetAuthForms", GLib.Variant("(asi)",
(forms, page_id)),
self.__on_get_forms, request, page_id)
def _on_dialog_response(self, dialog, response_id):
"""
Save user agent
@param dialog as Gtk.Dialog
@param response_id as int
"""
if response_id == Gtk.ResponseType.DELETE_EVENT:
return
user_agent = self.__entry.get_text()
El().websettings.set_user_agent(user_agent, self.__uri)
def _on_close_button_press_event(self, eventbox, event):
"""
Destroy self
@param eventbox as Gtk.EventBox
@param event as Gdk.Event
"""
if El().settings.get_enum("panel-mode") != PanelMode.MINIMAL:
self._window.container.pages_manager.close_view(self._view)
self.hide()
return True
def __on_paned_notify_position(self, paned, ignore):
"""
Update SitesManager width based on current position
@param paned as Gtk.Paned
@param ignore as GParamInt
"""
position = paned.get_position()
El().settings.set_value("sidebar-position",
GLib.Variant("i", position))
self.__sites_manager.set_minimal(position < 80)
def _on_clear_clicked(self, button):
"""
Clear finished downloads
@param button as Gtk.button
"""
self.__clear_button.set_sensitive(False)
for child in self.__listbox.get_children():
El().download_manager.remove(child.download)
if child.finished:
child.destroy()
def __on_button_press(self, widget, event):
"""
Hide popover if visible
@param widget as Gtk.Widget
@param event as Gdk.EventButton
"""
if event.type == Gdk.EventType._2BUTTON_PRESS:
self.__window.container.add_webview(El().start_page,
Gdk.WindowType.CHILD)
return self.__window.close_popovers()
def __on_show_sidebar_changed(self, settings, value):
"""
Show/hide panel
@param settings as Gio.Settings
@param value as bool
"""
if El().settings.get_value("show-sidebar"):
self.__sites_manager.show()
else:
self.__sites_manager.hide()
def update_zoom_level(self):
"""
Update zoom level
"""
try:
parsed = urlparse(self.get_uri())
if parsed.netloc in El().zoom_levels.keys():
zoom_level = El().zoom_levels[parsed.netloc]
else:
zoom_level = 100
if self.__related_view is None:
zoom_level *= self.get_ancestor(Gtk.Window).zoom_level
else:
zoom_level *= self.__related_view.get_ancestor(
Gtk.Window).zoom_level
except Exception as e:
print("WebView::update_zoom_level()", e)
debug("Update zoom level: %s" % zoom_level)
self.set_zoom_level(zoom_level / 100)
def _on_ok_button_clicked(self, button):
"""
Pass ok to js
@param button as Gtk.Button
"""
self.__request.allow()
self.hide()
if self.__switch.get_active():
El().websettings.allow_geolocation(self.__uri, True)
self.__window.toolbar.title.show_indicator(Indicator.GEOLOCATION)
