def init(self):
# basic restrictions
settings = WebKit2.Settings()
settings.set_enable_java(False)
settings.set_enable_plugins(False)
settings.set_enable_javascript(False)
self.html_view = WebKit2.WebView.new_with_settings(settings)
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.header = Gtk.Label.new()
self.header.set_halign(Gtk.Align.START)
self.header.set_valign(Gtk.Align.START)
self.header.set_property('margin', 10)
self.header.set_selectable(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.header, 0, 0, 1, 1)
grid.attach(self.html_view, 0, 1, 1, 1)
grid.attach(self.status, 0, 2, 1, 1)
return grid
def create_widgets(self):
""" Creates the widgets for the window """
# Read GUI from file and retrieve objects from Gtk.Builder
self.builder = Gtk.Builder.new_from_file("glade/main.glade")
self.builder.connect_signals(self)
self.webview = WebKit2.WebView()
self.webview.connect("notify::is-loading", self.is_loading)
self.webview.connect("load-changed", self.on_load_changed)
self.webview.connect("load-failed", self.on_load_failed)
self.webview.connect("decide-policy", self.on_policy_decision)
webviewSettings = WebKit2.Settings(enable_fullscreen=True,
enable_smooth_scrolling=True,
enable_dns_prefetching=True,
enable_webgl=True,
enable_media_stream=True,
enable_mediasource=True,
enable_encrypted_media=True,
enable_developer_extras=True)
self.webview.load_uri(self.app.get_config()['homepage'])
container = self.builder.get_object("main_container")
container.add(self.webview)
self.webview.show_all()
def main():
global webkit_renderer
global urlentry
builder = Gtk.Builder()
glade_file = pkg_resources.resource_filename(__name__, 'ui.glade')
builder.add_from_file(glade_file)
builder.connect_signals(Handler())
window = builder.get_object("main_window")
webkit_renderer = WebKit2.WebView()
# Settings
settings = WebKit2.Settings()
user_agent = settings.get_property('user-agent')
try:
webkit_version = user_agent.split()[4]
except IndexError:
webkit_version = ''
settings.set_property('user-agent', 'b3/0.0 ' + webkit_version)
webkit_renderer.set_settings(settings)
# The default URL to be loaded
webkit_renderer.load_uri("https://duckduckgo.com")
urlentry = builder.get_object("address_bar")
urlentry.set_text("https://duckduckgo.com")
scrolled_window = builder.get_object("scrolledwindow")
scrolled_window.add(webkit_renderer)
webkit_renderer.show()
window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()
def setup(self):
self.widget.proc_browser_box.add(self.browser)
browser_settings = WebKit2.Settings()
browser_settings.set_property("allow-universal-access-from-file-urls",
True)
browser_settings.set_property("enable-plugins", False)
browser_settings.set_property("default-font-size", 11)
self.browser.set_settings(browser_settings)
self.widget.proc_single_option.set_active(True)
self.widget.proc_dir_btn.connect('clicked', self.open_terminal)
self.widget.proc_mount_btn.connect('clicked', self.mount_sample)
self.widget.proc_strategy_btn.connect('clicked', self.use_strategy)
self.widget.proc_reports_view.connect('row-activated',
self.on_row_activated)
self.widget.proc_run_btn.connect('clicked', self.on_run_analysis)
self.widget.proc_clear_btn.connect('clicked', self.clear_reports)
self.widget.proc_open_btn.connect('clicked', self.import_metafile)
self.options = {
'screen': self.widget.proc_screen_option,
'merge': self.widget.proc_merge_option,
'mad': self.widget.proc_mad_option,
'calibrate': self.widget.proc_calib_option,
'integrate': self.widget.proc_integrate_option,
'anomalous': self.widget.proc_anom_btn
}
def __init__(self, parent, policy_file):
Gtk.Dialog.__init__(self, 'Privacy Policy', parent, 0,
(Gtk.STOCK_CLOSE, Gtk.ResponseType.OK))
self.set_title('Privacy Policy')
self.set_default_size(1000, 590)
self.set_position(Gtk.WindowPosition.CENTER_ON_PARENT)
self.set_decorated(False)
self.get_action_area().get_style_context().add_class('policy_buttons')
manager = WebKit2.WebsiteDataManager.new_ephemeral()
context = WebKit2.WebContext.new_with_website_data_manager(manager)
self.webview = WebKit2.WebView.new_with_context(context)
settings = WebKit2.Settings()
settings.set_enable_javascript(False)
settings.set_enable_java(False)
settings.set_enable_plugins(False)
self.webview.set_settings(settings)
self.webview.connect('context_menu', self.block_context_menu)
policy_file = 'file://%s' % policy_file
self.webview.load_uri(policy_file)
# TODO: The content area does not seem to resize its child elements
# automatically?
self.webview.set_size_request(-1, 590)
self.get_content_area().add(self.webview)
self.get_content_area().show_all()
self.show()
def __init__(self, options):
settings = WebKit2.Settings()
settings.set_property('allow-file-access-from-file-urls', True)
self._time_limit = 0
self._view = WebKit2.WebView.new_with_settings(settings)
self._view.connect('notify::title', self._on_title_changed)
self._result = None
self._id = 0
def _apply_webkit_settings(self):
self.web_view_settings = WebKit2.Settings()
all_settings = self._get_settings_for_webkit()
for setting_name, value in all_settings.items():
setting_name = 'set_{}'.format(setting_name)
set_setting = getattr(self.web_view_settings, setting_name)
set_setting(value)
def setup(self):
self.content_box.add(self.view)
browser_settings = WebKit2.Settings()
browser_settings.set_property("allow-universal-access-from-file-urls",
True)
browser_settings.set_property("enable-plugins", False)
browser_settings.set_property("default-font-size", 11)
self.view.set_settings(browser_settings)
self.back_btn.connect('clicked', self.go_back)
self.forward_btn.connect('clicked', self.go_forward)
self.view.connect('decide-policy', self.check_history)
self.view.connect('load-changed', self.on_loading)
def setup_document_view(self):
self.view_box = Gtk.Box.new(Gtk.Orientation.VERTICAL, 0)
self.html_view = WebKit2.WebView()
ws = WebKit2.Settings()
ws.set_auto_load_images(True)
self.html_view.set_settings(ws)
self.set_contents(DEFAULT_CONTENTS)
self.view_box.pack_start(self.html_view,
expand=True,
fill=True,
padding=0)
self.add(self.view_box)
def __init__(self, title, width=800, height=600):
Gtk.Window.__init__(self)
self.set_size_request(width, height)
self.set_resizable(False)
scrolled_window = Gtk.ScrolledWindow()
self.add(scrolled_window)
self.connect('delete-event', self.on_destroy)
# https://lazka.github.io/pgi-docs/WebKit2-4.0/classes/Settings.html
settings = WebKit2.Settings().new()
self.webview = WebKit2.WebView().new_with_settings(settings)
self.webview.connect('decide-policy', self.decide_policy_cb)
self.webview.connect('load_changed', self.load_changed_cb)
scrolled_window.add(self.webview)
def _setup_widget(self):
# Webkit context
self.web_context = WebKit.WebContext.get_default()
# ~ self.web_context.set_cache_model(WebKit.CacheModel.DOCUMENT_VIEWER)
self.web_context.set_process_model(
WebKit.ProcessModel.MULTIPLE_SECONDARY_PROCESSES)
# ~ web_context.register_uri_scheme('basico', self._on_basico_scheme)
# Webkit settings
self.web_settings = WebKit.Settings()
self.web_settings.set_enable_smooth_scrolling(True)
self.web_settings.set_enable_plugins(False)
WebKit.WebView.__init__(self,
web_context=self.web_context,
settings=self.web_settings)
self.srvgui.add_widget('browser_%s' % self.name, self)
self.connect('context-menu', self._on_append_items)
self.connect('decide-policy', self._on_decide_policy)
# ~ self.connect('load-changed', self._on_load_changed)
self.connect('load-failed', self._on_load_failed)
def __init__(self, on_loaded_cb=None):
"""Initialize the panorama viewer widget.
Args:
on_loaded_cb: an optional callback function/lambda that is called
after loading of the panorama widget completes.
"""
super(PanoramaViewer, self).__init__()
# Callback for when loading of the WebView completed.
self.on_loaded_cb = on_loaded_cb
# Callback for when loading of an image completed.
self.pending_on_completed_cb = None
# Settings
websettings = WebKit2.Settings()
websettings.set_property('enable-webgl', True)
websettings.set_property('enable-plugins', False)
#websettings.set_property('enable-developer-extras', True) # TODO: Enable this when debugging.
# Trying to work-around file access problems:
#websettings.set_property('enable-xss-auditor', False) # Detailed error reporting for external script files is blocked by crossorigin policies, but this property seems not to enable it.
#websettings.set_property('allow-file-access-from-file-url', True) # Not implemented :(
self.set_settings(websettings)
# Fill the parent widget.
self.set_hexpand(True)
self.set_vexpand(True)
# Load the panorama viewer page.
self.load_uri(self.uri_panorama_viewer)
# Disable context menu.
self.connect('context-menu', lambda *args: True)
# Set up communication from webview document to python:
context = self.get_context()
context.register_uri_scheme(self.custom_scheme, self._uri_scheme_cb)
# Detect navigation away from uri_panorama_viewer
self.connect("decide-policy", self._on_decide_policy)
def _open_settings(self):
""" """
settings = WebKit2.Settings()
settings.set_enable_java(False)
settings.set_enable_plugins(False)
settings.set_enable_javascript(True)
webview_oauth = WebKit2.WebView.new_with_settings(settings)
webview_oauth.set_property('expand', True)
webview_oauth.connect('load-changed', self._webview_oauth_changed)
webview_oauth.load_uri(SpotifyAPI.build_oauth_url())
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
vbox.pack_start(webview_oauth, True, True, 0)
win = Gtk.Window(title='Extension: Spotify')
win.set_border_width(10)
win.resize(400, 700)
win.add(vbox)
win.show_all()
def new_webview(self):
settings = WebKit2.Settings()
settings.set_enable_smooth_scrolling(True)
settings.set_media_playback_allows_inline(True)
settings.set_enable_javascript(True)
settings.set_enable_javascript_markup(True)
settings.set_enable_media(True)
settings.set_enable_media_capabilities(True)
settings.set_enable_mediasource(True)
settings.set_enable_media_stream(True)
settings.set_enable_encrypted_media(True)
settings.set_auto_load_images(True)
settings.set_allow_file_access_from_file_urls(True)
settings.set_allow_universal_access_from_file_urls(True)
settings.set_enable_hyperlink_auditing(True)
settings.set_enable_html5_local_storage(True)
settings.set_enable_html5_database(True)
settings.set_enable_offline_web_application_cache(True)
webview = WebKit2.WebView.new_with_settings(settings)
bg_color = Gdk.RGBA()
bg_color.parse("#000")
webview.set_background_color(bg_color)
return webview
def __init__(self, app):
super().__init__(application=app, title="Fava")
self.app = app
self.server = Server()
self.load_fava_icon()
settings = WebKit2.Settings()
settings.set_property("enable-developer-extras", True)
self.webview.set_settings(settings)
self.open_action = Gio.SimpleAction(name="file_open")
self.open_action.connect("activate", self.file_open)
self.add_action(self.open_action)
self.close_action = Gio.SimpleAction(name="close")
self.close_action.connect("activate", self.close)
self.add_action(self.close_action)
self.search_action = Gio.SimpleAction(name="search")
self.search_action.set_enabled(False)
self.search_action.connect("activate", self.search_start)
self.add_action(self.search_action)
self.search_toggle_action = Gio.SimpleAction.new_stateful(
name="search_toggle",
parameter_type=None,
state=GLib.Variant.new_boolean(False),
)
self.search_toggle_action.set_enabled(False)
self.search_toggle_action.connect("change-state", self.search_toggle)
self.add_action(self.search_toggle_action)
# workaround because
# `self.search_entry = Gtk.Template.Child()` does not work, neither does
# `self.get_template_child(Gtk.SearchEntry, "search_entry")`.
self.search_entry = find_child(
self.search_bar, lambda widget: isinstance(
widget, Gtk.SearchEntry)) # type: Gtk.SearchEntry
def activate(self):
self.view.settings = WebKit2.Settings()
self.view.settings.set_enable_java(False)
self.view.settings.set_enable_javascript(False)
self.view.settings.set_enable_javascript_markup(False)
self.view.settings.set_enable_plugins(False)
self.view.settings.set_enable_developer_extras(False)
self.view.settings.set_enable_page_cache(False)
self.view.content = WebKit2.WebView.new_with_settings(
self.view.settings)
self.view.content.set_can_focus(False)
self.view.stack.add_named(self.view.content, 'content')
self.view.stack.add_named(self.view.search_widget, 'search')
self.view.show_all()
self.controller = help_panel_controller.HelpPanelController(
self, self.view)
self.presenter = help_panel_presenter.HelpPanelPresenter(
self, self.view)
self.add_change_code('search_query_changed')
def _init_webview(self):
settings = WebKit2.Settings(
enable_developer_extras=bool(get_options().dev),
enable_hyperlink_auditing=False,
enable_page_cache=False,
enable_write_console_messages_to_stdout=True,
enable_xss_auditor=False,
hardware_acceleration_policy=WebKit2.HardwareAccelerationPolicy.
NEVER,
)
server = PreferencesContextServer.get_instance(self.get_application())
self.webview = WebKit2.WebView(settings=settings,
web_context=server.context)
server.client = self.webview
self.add(self.webview)
self.webview.show()
self.load_page()
# Show right click menu if running with --dev flag
self.webview.connect('context-menu', lambda *_: not get_options().dev)
inspector = self.webview.get_inspector()
inspector.connect("attach",
lambda inspector, target_view: WebKit2.WebView())
#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)
cfgweb.set_property('enable-write-console-messages-to-stdout', True)
cfgweb.set_property('enable-webaudio', False)
cfgweb.set_property('enable-webgl', False)
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)
def create_components(self):
self.left_box = Gtk.VBox()
self.left_box.set_hexpand(True)
self.button_box = Gtk.HBox()
self.right_box = Gtk.VBox()
self.line1 = Gtk.HBox()
self.line1.set_homogeneous(True)
self.line2 = Gtk.HBox()
self.line2.set_homogeneous(True)
self.heading = Gtk.Label()
self.heading.set_markup('<span size="xx-large"></span>')
self.heading.set_hexpand(True)
self.heading.set_vexpand(False)
self.heading.set_halign(Gtk.Align.START)
self.heading.set_valign(Gtk.Align.START)
self.short_description = Gtk.Label('')
self.short_description.set_hexpand(True)
self.short_description.set_vexpand(False)
self.short_description.set_halign(Gtk.Align.START)
self.short_description.set_valign(Gtk.Align.START)
self.version = Gtk.Label('Version: ')
self.version.set_hexpand(True)
self.version.set_vexpand(False)
self.version.set_halign(Gtk.Align.START)
self.version.set_valign(Gtk.Align.START)
self.last_updated_date = Gtk.Label('Last Updated: ')
self.last_updated_date.set_hexpand(True)
self.last_updated_date.set_vexpand(False)
self.last_updated_date.set_halign(Gtk.Align.START)
self.last_updated_date.set_valign(Gtk.Align.START)
self.developer = Gtk.Label('Developer: ')
self.developer.set_hexpand(True)
self.developer.set_vexpand(False)
self.developer.set_halign(Gtk.Align.START)
self.developer.set_valign(Gtk.Align.START)
self.license = Gtk.Label('License: ')
self.license.set_hexpand(True)
self.license.set_vexpand(False)
self.license.set_halign(Gtk.Align.START)
self.license.set_valign(Gtk.Align.START)
self.install = Gtk.Button('Install')
self.install.set_hexpand(False)
self.uninstall = Gtk.Button('Uninstall')
self.uninstall.set_hexpand(False)
self.update = Gtk.Button('Update')
self.update.set_hexpand(False)
self.image = Gtk.Image.new_from_file('')
self.image.set_hexpand(True)
self.image.set_halign(Gtk.Align.START)
self.image.set_valign(Gtk.Align.START)
self.details = WebKit2.WebView()
self.details.load_html('')
self.details.set_vexpand(True)
settings = WebKit2.Settings()
settings.set_default_font_family('Open Sans')
settings.set_default_font_size(14)
self.details.set_settings(settings)
self.package_info_label = Gtk.Label()
self.package_info_label.set_markup('<span size="xx-large">Screenshot</span>')
self.package_info_label.set_hexpand(True)
self.package_info_label.set_vexpand(False)
self.package_info_label.set_halign(Gtk.Align.END)
self.package_info_label.set_valign(Gtk.Align.START)
self.install.connect('clicked', misc.install_app, self.context)
self.uninstall.connect('clicked', misc.remove_app, self.context)
self.update.connect('clicked', misc.update_app, self.context)
def __init__(self, settings):
"""Initialize Book class
Args:
settings (Settings)
"""
self.settings = settings
# Webkit context
web_context = WebKit2.WebContext.get_default()
web_context.set_cache_model(WebKit2.CacheModel.DOCUMENT_VIEWER)
web_context.set_process_model(
WebKit2.ProcessModel.MULTIPLE_SECONDARY_PROCESSES)
# Webkit extensions
def setup_web_extensions(context):
application = Gio.Application.get_default()
variant_lvl = GLib.Variant.new_int32(logger.getEffectiveLevel())
context.set_web_extensions_directory(application.extensiondir)
context.set_web_extensions_initialization_user_data(variant_lvl)
web_context.connect('initialize-web-extensions', setup_web_extensions)
web_context.register_uri_scheme('epub', self._on_epub_scheme)
# Webkit settings
web_settings = WebKit2.Settings()
web_settings.set_default_font_size(self.settings.fontsize)
web_settings.set_enable_smooth_scrolling(True)
web_settings.set_enable_plugins(False)
# Enable developer tools (like web inspector)
if logger.getEffectiveLevel() <= logging.INFO:
web_settings.set_enable_developer_extras(True)
# Initialize
WebKit2.WebView.__init__(self,
web_context=web_context,
settings=web_settings)
# Background color of webview
gdk_color = Gdk.Color.parse(self.settings.color_bg)
gdk_rgba = Gdk.RGBA.from_color(gdk_color[1])
self.set_background_color(gdk_rgba)
# DBUS PCI
self.dbus_helper = DBusHelper()
# Variables
self.doc = Epub()
self.identifier = ''
self.__matches_list = []
self.__is_match_prev = False
self.__page_turning = False
# Signals
self.on_reload_chapter_id = 0
self.on_load_changed_id = self.connect('load-changed',
self._on_load_change)
self.on_decide_policy_id = self.connect('decide-policy',
self._on_decide_policy)
self.on_load_set_pos_id = 0
self.on_load_by_fragment_id = 0
self.on_load_by_search_id = 0
self.on_resize_id = 0
self.on_text_found_id = 0
self.on_text_not_found_id = 0
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):
Gtk.VBox.__init__(self)
self.get_style_context().add_class('help')
self.action_bar = Gtk.HBox()
self.action_bar.set_size_request(-1, 37)
self.home_button = Gtk.Button.new_from_icon_name(
'go-home-symbolic', Gtk.IconSize.MENU)
self.home_button.set_tooltip_text(_('Home'))
self.home_button.get_style_context().add_class('flat')
self.home_button.set_can_focus(False)
self.action_bar.pack_start(self.home_button, False, False, 0)
self.up_button = Gtk.Button.new_from_icon_name('go-up-symbolic',
Gtk.IconSize.MENU)
self.up_button.set_tooltip_text(_('Top'))
self.up_button.get_style_context().add_class('flat')
self.up_button.set_can_focus(False)
self.action_bar.pack_start(self.up_button, False, False, 0)
self.back_button = Gtk.Button.new_from_icon_name(
'go-previous-symbolic', Gtk.IconSize.MENU)
self.back_button.set_tooltip_text(_('Back'))
self.back_button.get_style_context().add_class('flat')
self.back_button.set_can_focus(False)
self.action_bar.pack_start(self.back_button, False, False, 0)
self.next_button = Gtk.Button.new_from_icon_name(
'go-next-symbolic', Gtk.IconSize.MENU)
self.next_button.set_tooltip_text(_('Forward'))
self.next_button.get_style_context().add_class('flat')
self.next_button.set_can_focus(False)
self.action_bar.pack_start(self.next_button, False, False, 0)
self.search_button = Gtk.ToggleButton()
self.search_button.set_image(
Gtk.Image.new_from_icon_name('edit-find-symbolic',
Gtk.IconSize.MENU))
self.search_button.set_tooltip_text(_('Find'))
self.search_button.get_style_context().add_class('flat')
self.search_button.set_can_focus(False)
self.action_bar.pack_end(self.search_button, False, False, 0)
self.pack_start(self.action_bar, False, False, 0)
self.settings = WebKit2.Settings()
self.settings.set_enable_java(False)
self.settings.set_enable_javascript(False)
self.settings.set_enable_javascript_markup(False)
self.settings.set_enable_plugins(False)
self.settings.set_enable_developer_extras(False)
self.settings.set_enable_page_cache(False)
self.content = WebKit2.WebView.new_with_settings(self.settings)
self.content.set_can_focus(False)
self.search_widget = Gtk.HBox()
self.search_vbox = Gtk.VBox()
self.search_vbox.set_margin_left(18)
self.search_vbox.set_margin_right(18)
self.search_entry = Gtk.SearchEntry()
self.search_entry.set_size_request(360, -1)
self.search_entry.set_margin_bottom(18)
self.search_result_items = list()
self.search_results = Gtk.ListBox()
self.search_results.set_size_request(300, 344)
self.search_results.set_can_focus(False)
self.search_results.set_selection_mode(Gtk.SelectionMode.NONE)
self.search_results.set_margin_left(26)
self.search_results.set_margin_right(26)
self.search_content_box = Gtk.VBox()
self.search_content_box.pack_start(self.search_entry, False, False, 0)
self.search_content_box.pack_start(self.search_results, False, False,
0)
self.search_vbox.set_center_widget(self.search_content_box)
self.search_widget.set_center_widget(self.search_vbox)
self.stack = Gtk.Stack()
self.stack.add_named(self.content, 'content')
self.stack.add_named(self.search_widget, 'search')
self.pack_start(self.stack, True, True, 0)
self.show_all()
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)
def addtab(self,
widget=None,
dummy=None,
dummier=None,
dummiest=None,
openurl="http://google.com/"):
self.web_view.append(WebKit2.WebView())
self.websettings.append(WebKit2.Settings())
# to set user agent, uncomment
self.websettings[len(self.websettings) - 1].set_property(
'user-agent', 'iPad') # won't set at all
# to enable, disable javascript
self.websettings[len(self.websettings) - 1].set_property(
'enable_javascript', False)
# to enable, disable webgl
self.websettings[len(self.websettings) - 1].set_property(
"enable-webgl", True)
self.web_view[len(self.web_view) - 1].set_settings(
self.websettings[len(self.websettings) - 1])
self.web_view[len(self.web_view) - 1].load_uri(openurl)
self.back_button.append(gtk.ToolButton(gtk.STOCK_GO_BACK))
self.back_button[len(self.back_button) - 1].connect(
"clicked", self.go_back)
self.forward_button.append(gtk.ToolButton(gtk.STOCK_GO_FORWARD))
self.forward_button[len(self.forward_button) - 1].connect(
"clicked", self.go_forward)
self.refresh_button.append(gtk.ToolButton(gtk.STOCK_REFRESH))
self.refresh_button[len(self.refresh_button) - 1].connect(
"clicked", self.refresh)
self.url_bar.append(gtk.Entry())
self.url_bar[len(self.url_bar) - 1].connect("activate", self.on_active)
# enable (green), disable (red) javascript
self.jsbutton.append(gtk.Button('js'))
self.jsbutton[len(self.jsbutton) - 1].connect("activate",
self.toggle_js)
self.jsbutton[len(self.jsbutton) - 1].connect("clicked",
self.toggle_js)
self.jsbutton[len(self.jsbutton) - 1].modify_bg(
gtk.StateType.NORMAL, Gdk.color_parse("red"))
self.etcbutton.append(gtk.Button('Prefs'))
self.historybutton.append(gtk.Button('Hist'))
self.historybutton[len(self.historybutton) - 1].connect(
"activate", self.historytab)
self.historybutton[len(self.historybutton) - 1].connect(
"clicked", self.historytab)
self.etcbutton[len(self.etcbutton) - 1].connect(
"activate", self.show_prefs)
self.etcbutton[len(self.etcbutton) - 1].connect(
"clicked", self.show_prefs)
self.newtab.append(gtk.Button('+'))
self.newtab[len(self.newtab) - 1].connect("activate", self.addtab)
self.newtab[len(self.newtab) - 1].connect("clicked", self.addtab)
self.closetab.append(gtk.Button('X'))
self.closetab[len(self.closetab) - 1].connect("activate",
self.removetab)
self.closetab[len(self.closetab) - 1].connect("clicked",
self.removetab)
self.web_view[len(self.web_view) - 1].connect("load_changed",
self.on_load_changed)
#self.web_view[len(self.web_view)-1].connect("download_requested", self.download)
self.scroll_window.append(gtk.ScrolledWindow(None, None))
self.scroll_window[len(self.scroll_window) - 1].add(
self.web_view[len(self.web_view) - 1])
self.scroll_window[len(self.scroll_window) - 1].set_policy(
gtk.PolicyType.AUTOMATIC, gtk.PolicyType.AUTOMATIC)
self.hbox.append(gtk.HBox(False, 0))
self.vbox.append(gtk.VBox(False, 0))
self.mainbox = gtk.VBox(False, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.back_button[len(self.back_button) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.forward_button[len(self.forward_button) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.refresh_button[len(self.refresh_button) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.newtab[len(self.newtab) - 1], False, True, 3)
self.hbox[len(self.hbox) - 1].pack_start(
self.closetab[len(self.closetab) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.url_bar[len(self.url_bar) - 1], True, True, 3)
self.hbox[len(self.hbox) - 1].pack_start(
self.jsbutton[len(self.jsbutton) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.historybutton[len(self.historybutton) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.etcbutton[len(self.etcbutton) - 1], False, True, 0)
self.vbox[len(self.vbox) - 1].pack_start(self.hbox[len(self.hbox) - 1],
False, True, 0)
self.vbox[len(self.vbox) - 1].pack_start(
self.scroll_window[len(self.scroll_window) - 1], True, True, 0)
self.tabbook.append_page(self.vbox[len(self.vbox) - 1])
self.tabbook.show_all()
self.tabbook.set_current_page(len(self.vbox) - 1 + self.n)
