def _set_up_widgets(self):
self._manager = WebKit.UserContentManager()
self.connect('key-press-event', self._on_key_pressed)
self._view_stack = Gtk.Stack()
self._view_stack.set_transition_duration(500)
self.pack_start(self._view_stack, True, True, 0)
def init(self):
# basic restrictions
self.stylesheet = None
self.manager = WebKit2.UserContentManager()
self.html_view = WebKit2.WebView.new_with_user_content_manager(
self.manager)
settings = self.html_view.get_settings()
settings.set_enable_java(False)
settings.set_enable_plugins(False)
settings.set_enable_javascript(False)
# uncomment to show web inspector
# settings.set_enable_developer_extras(True)
self.html_view.set_property('expand', True)
self.html_view.connect('mouse-target-changed', self.on_mouse_over)
self.html_view.connect('context-menu', self.on_context_menu)
self.html_view.connect('decide-policy', self.on_decide_policy)
# give the vertical space to the html view!
self.text_view.set_property('hexpand', True)
self.status = Gtk.Label.new()
self.status.set_halign(Gtk.Align.START)
self.status.set_valign(Gtk.Align.END)
self.set_status(None)
grid = Gtk.Grid()
grid.attach(self.text_view, 0, 0, 1, 1)
grid.attach(self.html_view, 0, 1, 1, 1)
grid.attach(self.status, 0, 2, 1, 1)
return grid
def _build_ui(self):
self.set_position(Gtk.WindowPosition.CENTER)
# Create HeaderBar
headerbar = Gtk.HeaderBar()
headerbar.set_show_close_button(True)
headerbar.show_all()
# Create webview with custom stylesheet
css = WebKit2.UserStyleSheet(
".sidebar, .banner { display: none; }",
WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
content_manager = WebKit2.UserContentManager()
content_manager.add_style_sheet(css)
self.webview = WebKit2.WebView.new_with_user_content_manager(
content_manager)
self.webview.connect("resource-load-started", self.cb_load_started)
self.webview.show()
scrolledwindow = Gtk.ScrolledWindow()
scrolledwindow.add(self.webview)
scrolledwindow.show()
# Add children to ApplicationWindow
self.add(scrolledwindow)
self.set_titlebar(headerbar)
def __init__(self):
self.window = Gtk.Window()
self.window.set_icon_from_file(get_resource_path("icon.png"))
self.window.set_size_request(1000, 600)
self.window.set_default_size(800, 600)
self.s = Gtk.ScrolledWindow()
self.context = WebKit2.WebContext.get_default()
sm = self.context.get_security_manager()
self.cookies = self.context.get_cookie_manager()
self.manager = WebKit2.UserContentManager()
self.view = WebKit2.WebView.new_with_user_content_manager(self.manager)
self.settings = self.view.get_settings()
cookies_path = '/tmp/cookies.txt'
storage = WebKit2.CookiePersistentStorage.TEXT
policy = WebKit2.CookieAcceptPolicy.ALWAYS
self.cookies.set_accept_policy(policy)
self.cookies.set_persistent_storage(cookies_path, storage)
self.view.load_uri("https://music.yandex.ru/")
self.s.add(self.view)
self.hb = Gtk.HeaderBar()
self.hb.set_show_close_button(True)
self.window.set_titlebar(self.hb)
button = Gtk.Button()
icon = Gio.ThemedIcon(name="mail-send-receive-symbolic")
image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
button.add(image)
button.connect("clicked", self.on_refresh)
self.hb.pack_end(button)
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
Gtk.StyleContext.add_class(box.get_style_context(), "linked")
button1 = Gtk.Button()
button1.add(Gtk.Arrow(Gtk.ArrowType.LEFT, Gtk.ShadowType.NONE))
button1.connect("clicked", self.on_back)
box.add(button1)
self.button_play = Gtk.Button.new_with_label("Play/Pause")
self.button_play.connect("clicked", self.on_play)
box.add(self.button_play)
button2 = Gtk.Button()
button2.add(Gtk.Arrow(Gtk.ArrowType.RIGHT, Gtk.ShadowType.NONE))
button2.connect("clicked", self.on_next)
box.add(button2)
self.hb.pack_start(box)
self.window.add(self.s)
self.window.show_all()
self.window.connect('destroy', self.destroy)
def _user_content_manager(self):
mgr = WebKit2.UserContentManager()
script = WebKit2.UserScript(
"Notification.requestPermission();",
WebKit2.UserContentInjectedFrames.TOP_FRAME,
WebKit2.UserScriptInjectionTime.START, None, None)
mgr.add_script(script)
return mgr
def __init__(self):
user_content = WebKit2.UserContentManager()
super().__init__(user_content_manager=user_content)
web_settings = self.get_settings()
web_settings.set_default_font_size(settings.get_int('font-size'))
settings.connect('changed::font-size',
self._settings_font_size_changed_cb, web_settings)
self._set_style()
def __init__(self, **kwargs):
cm = WebKit2.UserContentManager()
cm.register_script_message_handler('scrolled');
cm.connect('script-message-received::scrolled',
lambda cm, result: self.emit('scrolled',
result.get_js_value().to_double()))
cm.register_script_message_handler('scrolled_top');
cm.connect('script-message-received::scrolled_top',
lambda cm, result: self.emit('scrolled-top'))
cm.register_script_message_handler('scrolled_bottom');
cm.connect('script-message-received::scrolled_bottom',
lambda cm, result: self.emit('scrolled-bottom'))
cm.register_script_message_handler('selection_changed');
cm.connect('script-message-received::selection_changed',
lambda cm, result: self.emit('selection-changed',
result.get_js_value().to_boolean()))
cm.add_script(WebKit2.UserScript('''
window.addEventListener("scroll", function(){
var handler = window.webkit.messageHandlers.scrolled;
handler.postMessage(window.scrollY);
});
document.addEventListener("selectionchange", function() {
var handler = window.webkit.messageHandlers.selection_changed;
handler.postMessage(window.getSelection() != '');
});
''',
WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserScriptInjectionTime.START, None, None))
cm.add_style_sheet(WebKit2.UserStyleSheet('''
html { margin: 50px; }
body { overflow: hidden; }
''',
WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None))
WebKit2.WebView.__init__(self, user_content_manager=cm, **kwargs)
self.get_settings().set_enable_write_console_messages_to_stdout(True)
def new_content_manager(self):
css = """
.icn--close {
visibility: hidden;
}
button#continue_offline {
visibility: hidden;
}
"""
content_injected_frames = WebKit2.UserContentInjectedFrames(0)
user_style_level = WebKit2.UserStyleLevel(0)
style_sheet = WebKit2.UserStyleSheet(css, content_injected_frames,
user_style_level, None, None)
content_manager = WebKit2.UserContentManager()
content_manager.add_style_sheet(style_sheet)
return content_manager
def init(self):
self.episode = None
self._base_uri = None
# basic restrictions
self.stylesheet = None
self.manager = WebKit2.UserContentManager()
self.html_view = WebKit2.WebView.new_with_user_content_manager(self.manager)
settings = self.html_view.get_settings()
settings.set_enable_java(False)
settings.set_enable_plugins(False)
settings.set_enable_javascript(False)
# uncomment to show web inspector
# settings.set_enable_developer_extras(True)
self.html_view.set_property('expand', True)
self.html_view.connect('mouse-target-changed', self.on_mouse_over)
self.html_view.connect('context-menu', self.on_context_menu)
self.html_view.connect('decide-policy', self.on_decide_policy)
self.html_view.connect('authenticate', self.on_authenticate)
return self.html_view
def __init__(self, library):
Gtk.Grid.__init__(self, expand=True)
library
stylesheet = """
:root {
font-family: 'Open Sans', 'sans-serif';
color: #333;
font-size: 100%;
}
.main {
min-width: 32rem;
max-width: 100rem;
word-wrap: break-word;
line-height: 1.5rem;
margin: 0 auto 4rem auto;
padding: 0 1rem 0 1rem;
columns: 3 28rem;
}
span.verse-num {
color: #999;
font-size: .75rem;
font-weight: bold;
padding-right: .15rem;
padding-left: .25rem;
vertical-align: text-top;
}
h1 { font-size: 2rem }
h2 {
font-size: 1.5rem;
column-span: all;
}
h3 {
font-size: 1.125rem;
font-weight: lighter;
}
h4 { font-size: 1rem }
h5 { font-size: .875rem }
h6 { font-size: .75rem }
.mx-auto { margin-left: auto; margin-right: auto; }
.divineName { font-variant: small-caps; }
.wordsOfJesus { color: #7a0000 }
.indent1 { margin-left: .5rem }
.indent2 { margin-left: 1rem }
.indent3 { margin-left: 2rem }
.indent4 { margin-left: 4rem }
"""
user_style = WebKit2.UserStyleSheet(
stylesheet, WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
content_manager = WebKit2.UserContentManager()
content_manager.add_style_sheet(user_style)
self.webview = WebKit2.WebView.new_with_user_content_manager(
content_manager)
self.webview.props.expand = True
self.webview.connect('context-menu', self._on_context_menu)
self.add(self.webview)
library.connect('reference-changed', self._on_library_changed)
library.connect('module-changed', self._on_library_changed)
self.show_all()
def __init__(self):
GLib.set_prgname('devdocs-desktop')
GLib.set_application_name('DevDocs')
self.args = argparse.ArgumentParser(prog='devdocs-desktop')
self.args.add_argument('s',
metavar='STR',
help='the string to search',
nargs='?',
default='')
self.app_url = 'https://devdocs.io'
self.search = self.args.parse_args().s.strip()
self.filter = ''
self.open_link = False
self.options = self.read_settings_json('cookies')
self.prefs = self.read_settings_json('prefs')
self.globals = Gtk.Settings.get_default()
self.main = Gtk.Builder()
self.main.add_from_file(self.file_path('ui/main.ui'))
self.main.connect_signals(self)
self.settings = WebKit2.Settings()
self.settings.set_enable_page_cache(True)
self.settings.set_enable_offline_web_application_cache(True)
self.cookies = WebKit2.WebContext.get_default().get_cookie_manager()
self.cookies.connect('changed', self.on_cookies_changed)
self.manager = WebKit2.UserContentManager()
self.webview = WebKit2.WebView.new_with_user_content_manager(
self.manager)
self.webview.set_settings(self.settings)
self.webview.load_uri(self.url_with_search())
self.history = self.webview.get_back_forward_list()
self.history.connect('changed', self.on_history_changed)
self.webview.connect('notify::uri', self.on_webview_uri_changed)
self.webview.connect('notify::title', self.on_webview_title_changed)
self.webview.connect('decide-policy', self.on_webview_decide_policy)
self.webview.connect('context-menu', self.on_webview_context_menu)
self.scrolled = self.main.get_object('scrolled_main')
self.scrolled.add(self.webview)
self.header_back = self.main.get_object('header_button_back')
self.header_forward = self.main.get_object('header_button_forward')
self.header_title = self.main.get_object('header_label_title')
self.header_save = self.main.get_object('header_button_save')
self.header_sbox = self.main.get_object('header_box_search')
self.header_filter = self.main.get_object('header_button_filter')
self.header_filter.set_label('')
self.header_search = self.main.get_object('header_search_entry')
self.header_search.get_style_context().remove_class('search')
self.header_search.set_text(self.search)
self.revealer = self.main.get_object('revealer_main')
self.finder_search = self.main.get_object('finder_search_entry')
self.finder_next = self.main.get_object('finder_button_next')
self.finder_prev = self.main.get_object('finder_button_prev')
self.finder_label = self.main.get_object('finder_label')
self.finder = WebKit2.FindController(web_view=self.webview)
self.finder.connect('counted-matches', self.on_finder_counted_matches)
self.finder.connect('found-text', self.on_finder_found_text)
self.finder.connect('failed-to-find-text',
self.on_finder_failed_to_find_text)
self.window = self.main.get_object('window_main')
self.window.show_all()
self.create_settings_path()
self.inject_custom_styles()
self.inject_custom_scripts()
self.enable_persistent_cookies()
self.set_window_accel_groups()
self.toggle_theme_variation()
self.set_zoom_level()
def __init__(self):
# security: clear the clipboard because the Javascript can access it and avoid access sensitive data
clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
clipboard.clear()
Gtk.Window.__init__(self)
self.set_position(Gtk.WindowPosition.CENTER)
self.set_default_size(1152, 800)
self.scripts = None
contentManager = WebKit2.UserContentManager()
contentManager.connect("script-message-received::COMM_CHANNEL_JS_WK", self.__handleScriptMessage)
if not contentManager.register_script_message_handler("COMM_CHANNEL_JS_WK"):
print("Error registering script message handler: COMM_CHANNEL_JS_WK")
# Init the WebView with the contentManager
mydir = path.abspath(path.dirname(__file__))
print("Extension directory:", mydir)
ctx = WebKit2.WebContext.get_default()
ctx.set_web_extensions_directory(mydir)
ctx.set_tls_errors_policy(WebKit2.TLSErrorsPolicy.IGNORE) # ignore TLS Errors
self.web_view = WebKit2.WebView.new_with_context(ctx).new_with_user_content_manager(contentManager)
self.web_view.connect("load-changed", self.__loadFinishedCallback)
# Settings: Javascript messages need to be accessed via clipboard
settings = WebKit2.Settings()
settings.set_property('javascript-can-access-clipboard', True)
# Apply the rest of settings
settings.set_property('user-agent', 'iPad ewhjwhdsej')
settings.set_property('enable-plugins', False)
settings.set_property('enable-java', False)
settings.set_property('enable-javascript', True)
settings.set_property('allow-modal-dialogs', True)
settings.set_property('enable-private-browsing', True)
settings.set_property('enable-page-cache', True)
settings.set_property('enable-smooth-scrolling', True)
settings.set_property('enable-write-console-messages-to-stdout', True)
self.web_view.set_settings(settings)
cancelButton = Gtk.Button()
icon = Gio.ThemedIcon(name="window-close-symbolic")
image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.SMALL_TOOLBAR)
cancelButton.add(image)
cancelButton.connect("clicked", self.__close)
headerBar = Gtk.HeaderBar()
headerBar.set_show_close_button(False)
self.set_titlebar(headerBar)
boxTitle = Gtk.Box(spacing = 6)
self.spinner = Gtk.Spinner()
boxTitle.add(self.spinner)
labelTitle = Gtk.Label()
labelFont = labelTitle.get_pango_context().get_font_description()
labelFont.set_weight(Pango.Weight.BOLD)
labelTitle.modify_font(labelFont)
labelTitle.set_text(start_url)
boxTitle.add(labelTitle)
headerBar.set_custom_title(boxTitle)
self.stopButton = Gtk.Button()
icon = Gio.ThemedIcon(name="media-playback-stop-symbolic")
image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.SMALL_TOOLBAR)
self.stopButton.add(image)
self.stopButton.connect("clicked", self.__on_stop_click)
headerBar.pack_end(self.stopButton)
box = Gtk.Box()
Gtk.StyleContext.add_class(box.get_style_context(), "linked")
box.add(cancelButton)
headerBar.pack_start(box)
browserBox = Gtk.Box()
browserBox.set_orientation(Gtk.Orientation.VERTICAL)
browserBox.pack_start(self.web_view, True, True, 0)
self.add(browserBox)
#gi.require_version('Gdk', '3.0')
gi.require_version('WebKit2', '4.0')
from gi.repository import WebKit2, Gtk #, Gdk
#mydir = path.abspath(path.dirname(__file__))
mydir = path.abspath('./webkit-py-extensions')
#print("Current Webkit Extension directory:", mydir)
#GObject.threads_init()
ctx = WebKit2.WebContext.get_default()
ctx.set_web_extensions_directory(mydir)
ctx.set_tls_errors_policy(WebKit2.TLSErrorsPolicy.IGNORE) # ignore TLS Errors
#ctx.set_web_extensions_initialization_user_data(GLib.Variant.new_string("test string"))
contentManager = WebKit2.UserContentManager()
web = WebKit2.WebView.new_with_context(ctx).new_with_user_content_manager(
contentManager)
cfgweb = WebKit2.Settings()
cfgweb.set_property('default-charset', 'UTF-8')
cfgweb.set_property('user-agent', userAgent)
cfgweb.set_property('enable-plugins', False)
cfgweb.set_property('enable-java', False)
cfgweb.set_property('enable-javascript', True)
cfgweb.set_property('javascript-can-access-clipboard', False)
cfgweb.set_property('javascript-can-open-windows-automatically', False)
cfgweb.set_property('allow-modal-dialogs', True)
cfgweb.set_property('enable-private-browsing', True)
cfgweb.set_property('enable-page-cache', True)
cfgweb.set_property('enable-smooth-scrolling', False)
def __init__(self):
W = Gtk.Window
if settings("window", "hint_type") == "desktop" or \
settings("window", "hint_type") == "dock":
W.__init__(self,
title=settings("app", "name"),
skip_pager_hint=True,
skip_taskbar_hint=True)
else:
W.__init__(self, title=settings("app", "name"))
# create webview
context = WebKit2.WebContext.get_default()
sm = context.get_security_manager()
self.manager = WebKit2.UserContentManager()
self.webview = WebKit2.WebView.new_with_user_content_manager(
self.manager)
self.add(self.webview)
self.settings = self.webview.get_settings()
if settings("webkit", "user_agent"):
self.settings.set_user_agent(settings("webkit", "user_agent"))
print("Identifying User Agent as - " + self.settings.get_user_agent())
if settings("webkit", "site_quirks"):
# some website features wont work without this
self.settings.set_property("enable-site-specific-quirks", True)
def get_storage_path():
storage_path = os.getenv("HOME") + "/.jak/"
return storage_path
def set_storage():
context.set_favicon_database_directory(get_storage_path())
context.get_favicon_database()
if settings("webkit", "cache") == "local":
cache_model = WebKit2.CacheModel.DOCUMENT_BROWSER
set_storage()
elif settings("webkit", "cache") == "online":
cache_model = WebKit2.CacheModel.WEB_BROWSER
self.settings.set_property("enable-offline-web-application-cache",
True)
self.settings.set_property("enable-dns-prefetching", True)
self.settings.set_property("enable-page-cache", True)
# we only need cookies if we are online
app_name = settings("app", "name")
cookies_filename = "cookies.txt"
set_storage()
try:
if not os.path.exists(get_storage_path()):
os.makedirs(get_storage_path())
except OSError:
print("Error: Creating cookies directory. " +
get_storage_path())
self.session = context.get_cookie_manager()
storage = WebKit2.CookiePersistentStorage.TEXT
policy = WebKit2.CookieAcceptPolicy.ALWAYS
self.session.set_accept_policy(policy)
self.session.set_persistent_storage(
get_storage_path() + cookies_filename, storage)
def cookies_change(self):
pass
self.session.connect("changed", cookies_change)
else:
cache_model = WebKit2.CacheModel.DOCUMENT_VIEWER
print("Default no CACHE")
context.set_cache_model(cache_model)
screen = W.get_screen(self)
if os.path.isfile(options.route + "window.css"):
load_window_css(options.route + "window.css")
if settings("window", "transparent") is True:
# TODO transparent window is not working
color = screen.get_rgba_visual()
if color is not None and screen.is_composited():
self.set_app_paintable(True)
css = b"""
#jade-window, #jade-dock, #jade-desktop {
background-color: rgba(0,0,0,0);
} """
load_window_css(css)
self.webview.set_background_color(Gdk.RGBA(0, 0, 0, 0))
else:
print("Your system does not supports composite windows")
# https://lazka.github.io/pgi-docs/#Gdk-3.0/enums.html#Gdk.WindowTypeHint
if settings("window", "hint_type") == "desktop":
W.set_type_hint(self, Gdk.WindowTypeHint.DESKTOP)
elif settings("window", "hint_type") == "dialog":
W.set_type_hint(self, Gdk.WindowTypeHint.DIALOG)
elif settings("window", "hint_type") == "tooltip":
W.set_type_hint(self, Gdk.WindowTypeHint.TOOLTIP)
elif settings("window", "hint_type") == "notification":
W.set_type_hint(self, Gdk.WindowTypeHint.NOTIFICATION)
elif settings("window", "hint_type") == "dock":
W.set_type_hint(self, Gdk.WindowTypeHint.DOCK)
elif settings("window", "hint_type") == "menu":
W.set_type_hint(self, Gdk.WindowTypeHint.MENU)
elif settings("window", "hint_type") == "toolbar":
W.set_type_hint(self, Gdk.WindowTypeHint.TOOLBAR)
elif settings("window", "hint_type") == "utility":
W.set_type_hint(self, Gdk.WindowTypeHint.UTILITY)
elif settings("window", "hint_type") == "splashscreen":
W.set_type_hint(self, Gdk.WindowTypeHint.SPLASHSCREEN)
elif settings("window", "hint_type") == "dropdownmenu":
W.set_type_hint(self, Gdk.WindowTypeHint.DROPDOWN_MENU)
elif settings("window", "hint_type") == "popupmenu":
W.set_type_hint(self, Gdk.WindowTypeHint.POPUP_MENU)
else:
W.set_type_hint(self, Gdk.WindowTypeHint.NORMAL)
W.set_position(self, Gtk.WindowPosition.CENTER)
if os.path.isfile(settings("window", "icon")):
W.set_icon_from_file(self, settings("window", "icon"))
if settings("window", "resizable") is False:
W.set_resizable(self, False)
if settings("window", "decorated") is False:
W.set_decorated(self, False)
if settings("window", "full_screen") is True:
W.set_default_size(self, screen.width(), screen.height())
else:
W.set_default_size(self, settings("window", "width"),
settings("window", "height"))
if options.video:
W.set_keep_above(self, True)
W.set_gravity(self, Gdk.Gravity.SOUTH_EAST)
# in multi head setups this will be the last screen
W.move(self, screen.width(), screen.height())
self.settings.set_enable_smooth_scrolling(self)
self.settings.set_default_charset("UTF-8")
self.settings.set_property("allow-universal-access-from-file-urls",
True)
self.settings.set_property("allow-file-access-from-file-urls", True)
self.settings.set_property("enable-spatial-navigation",
True) # this is good for usability
self.settings.set_property("enable-java", False)
self.settings.set_property("enable-plugins", False)
self.settings.set_property("enable-accelerated-2d-canvas", True)
if settings("webkit", "debug") or options.debug:
self.webview.run_javascript(
"alert('Running in DEBUG MODE this is only intended for Development. "
+
"Any keys you press will be seen in the shell use with CAUTION!')"
)
self.settings.set_property("enable-developer-extras", True)
self.settings.set_property(
"enable-write-console-messages-to-stdout", True)
# disable all cache in debug mode
self.settings.set_property("enable-offline-web-application-cache",
False)
self.settings.set_property("enable-page-cache", False)
if not settings("webkit", "context_menu"):
# Disable webview rigth click menu
def disable_menu(*args):
return True
self.webview.connect("context-menu", disable_menu)
if settings("webkit", "cache") != "online" and app_mode != "url":
# only for local application
_name = settings("app", "name")
_description = settings("app", "description")
_version = settings("app", "version")
_author = settings("app", "author")
_license = settings("app", "license")
_url = settings("app", "url")
_screen_width = screen.width()
_screen_height = screen.height()
# TODO javascript Api
Api.js = '''
var JAK = {
'app': {
'getName' : '%(_name)s',
'getDescription' : '%(_description)s',
'getVersion' : '%(_version)s',
'getAuthor' : '%(_author)s',
'getLicense' : '%(_license)s',
'getUrl' : '%(_url)s',
'getScreenWidth' : %(_screen_width)s,
'getScreenHeight' : %(_screen_height)s
}};
''' % locals()
self.webview.run_javascript(Api.js)
def register_app(route):
context.register_uri_scheme(route, scheme_callback, None, None)
sm.register_uri_scheme_as_cors_enabled(route)
if settings("webkit", "same_frame") is not None:
for domain in settings("webkit", "same_frame"):
context.register_uri_scheme(domain, scheme_callback, None,
None)
sm.register_uri_scheme_as_cors_enabled(domain)
def scheme_callback(self, request):
pass
def load_app(mode, route):
if mode == "url":
# force ssl
if not options.debug and route.startswith("http:"):
route = route.replace("http:", "https:")
self.webview.load_uri(route)
elif mode == "module":
self.webview.load_html(Api.html, "file://" + route)
elif mode == "folder":
self.webview.load_uri("file://" + route + "/index.html")
register_app(route)
load_app(app_mode, options.route)
# Get title from webview for http
def on_title_changed(view, title):
"""
:param view:
:param title:
"""
url = self.webview.get_uri()
if url.startswith("http"):
title = self.webview.get_title()
title = title.rstrip()
W.set_title(self, title)
def on_key_release_event(self, event):
if settings("webkit", "debug") or options.debug:
# this can be used to find out key names
print("KeyPress = " + Gdk.keyval_name(event.keyval))
# distraction free mode, this only works on decorated windows
if event.keyval == Gdk.KEY_F11:
is_full_screen = self.get_window().get_state() & \
Gdk.WindowState.FULLSCREEN != False
if is_full_screen:
W.unfullscreen(self)
else:
W.fullscreen(self)
return True
# webpage zoom keys
elif event.keyval == Gdk.KEY_equal and event.state == Gdk.ModifierType.CONTROL_MASK or \
event.keyval == Gdk.KEY_minus and event.state == Gdk.ModifierType.CONTROL_MASK:
zoom = self.webview.get_zoom_level()
value = 0.1
if event.keyval == Gdk.KEY_minus:
if zoom <= 0.4:
# reset value
value = 1.0
else:
value = zoom - value
elif event.keyval == Gdk.KEY_equal:
if zoom >= 1.8:
# reset value
value = 1.0
else:
value = zoom + value
self.webview.set_zoom_level(round(value, 2))
def on_decide_policy(view, decision, decision_type):
"""
:param view:
:param decision:
:param decision_type:
"""
if decision_type == WebKit2.PolicyDecisionType.NAVIGATION_ACTION or \
decision_type == WebKit2.PolicyDecisionType.NEW_WINDOW_ACTION:
if decision.get_navigation_action().get_request().get_uri(
) == "about:blank":
# ignore blank pages
decision.ignore()
return True
elif decision_type == WebKit2.PolicyDecisionType.RESPONSE:
MIMES = (
"application/vnd.oasis.opendocument.text",
"application/pdf",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
"application/vnd.openxmlformats-officedocument.presentationml.presentation",
"application/zip",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
"application/vnd.oasis.opendocument.spreadsheet")
response = decision.get_response()
mime_type = response.props.mime_type
if mime_type in MIMES:
decision.download()
else:
decision.use()
return False
def favicon_changed(view, event):
# webpage icon changed
icon = view.get_favicon()
# set as window icon
pixbuf = Gdk.pixbuf_get_from_surface(icon, 0, 0, icon.get_width(),
icon.get_height())
#Gtk.IconInfo.load_icon(pixbuf)
W.set_icon(self, pixbuf)
def on_show_notification(view, notification):
self.set_urgency_hint(True)
notify = Gio.Notification.new(notification.get_title())
notify.set_body(notification.get_body())
return False
def on_permission_request(view, request):
if isinstance(request, WebKit2.NotificationPermissionRequest):
request.allow()
return True
self.webview.connect("show-notification", on_show_notification)
self.webview.connect("permission-request", on_permission_request)
self.webview.connect("decide-policy", on_decide_policy)
self.webview.connect("notify::favicon", favicon_changed)
self.webview.connect("notify::title", on_title_changed)
self.connect("key-release-event", on_key_release_event)
self.connect("delete-event", Gtk.main_quit)
self.show_all(
) # maybe i should only show the window wen the webview finishes loading?
class ViewSettings:
web_settings = WebKit2.Settings()
user_content = WebKit2.UserContentManager()
style_manager = Handy.StyleManager.get_default()
# Load custom css and connect view settings signals
def __init__(self):
self.web_settings.set_default_font_size(settings.get_int('font-size'))
gfile = Gio.File.new_for_uri(
'resource:///com/github/hugolabe/Wike/styles/view.min.css')
try:
gfile_contents = gfile.load_contents(None)
except:
print('Can\'t load view css file from resources')
self._css_view = ''
else:
self._css_view = gfile_contents[1].decode('utf-8')
gfile = Gio.File.new_for_uri(
'resource:///com/github/hugolabe/Wike/styles/dark.min.css')
try:
gfile_contents = gfile.load_contents(None)
except:
print('Can\'t load dark css file from resources')
self._css_dark = ''
else:
self._css_dark = gfile_contents[1].decode('utf-8')
gfile = Gio.File.new_for_uri(
'resource:///com/github/hugolabe/Wike/styles/sepia.min.css')
try:
gfile_contents = gfile.load_contents(None)
except:
print('Can\'t load sepia css file from resources')
self._css_sepia = ''
else:
self._css_sepia = gfile_contents[1].decode('utf-8')
self.set_style()
settings.connect('changed::font-size',
self._settings_font_size_changed_cb)
settings.connect('changed::custom-font',
self._settings_custom_font_changed_cb)
settings.connect('changed::font-family',
self._settings_custom_font_changed_cb)
settings.connect('changed::preview-popups',
self._settings_preview_popups_changed_cb)
settings.connect('changed::theme', self._settings_theme_changed_cb)
self.style_manager.connect('notify::dark',
self._system_theme_changed_cb)
# Settings font-size changed event
def _settings_font_size_changed_cb(self, settings, key):
self.web_settings.set_default_font_size(settings.get_int('font-size'))
# Settings custom font changed event
def _settings_custom_font_changed_cb(self, settings, key):
self.set_style()
# Settings preview popups changed event
def _settings_preview_popups_changed_cb(self, settings, key):
self.set_style()
# Settings theme changed event
def _settings_theme_changed_cb(self, settings, key):
self.set_style()
# System theme changed event
def _system_theme_changed_cb(self, style_manager, dark):
self.set_style()
# Inject stylesheets for customize article view
def set_style(self):
data_manager = web_context.get_website_data_manager()
data_manager.clear(WebKit2.WebsiteDataTypes.MEMORY_CACHE, 0, None,
None, None)
self.user_content.remove_all_style_sheets()
style_view = WebKit2.UserStyleSheet(
self._css_view, WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
self.user_content.add_style_sheet(style_view)
theme = settings.get_int('theme')
if theme == 1:
style_dark = WebKit2.UserStyleSheet(
self._css_dark, WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
self.user_content.add_style_sheet(style_dark)
elif theme == 2:
style_sepia = WebKit2.UserStyleSheet(
self._css_sepia, WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
self.user_content.add_style_sheet(style_sepia)
elif theme == 3:
if self.style_manager.get_dark():
style_dark = WebKit2.UserStyleSheet(
self._css_dark,
WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
self.user_content.add_style_sheet(style_dark)
if settings.get_boolean('custom-font'):
css_font = 'body,h1,h2{font-family:"' + settings.get_string(
'font-family') + '"!important}'
style_font = WebKit2.UserStyleSheet(
css_font, WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
self.user_content.add_style_sheet(style_font)
if not settings.get_boolean('preview-popups'):
css_previews = '.mwe-popups{display:none!important}'
style_previews = WebKit2.UserStyleSheet(
css_previews, WebKit2.UserContentInjectedFrames.ALL_FRAMES,
WebKit2.UserStyleLevel.USER, None, None)
self.user_content.add_style_sheet(style_previews)
