def __init__(self, com_pipe: object, com_dict: object): """ Initialize the process. """ from gi.repository import Soup as libsoup from gi.repository import WebKit as libwebkit from gi.repository import Gtk as gtk from gi.repository import Gdk as gdk from gi.repository import GLib as glib self._icon_db = libwebkit.get_favicon_database() # proxy_uri = libsoup.URI.new(os.getenv('http_proxy')) # session = libwebkit.get_default_session() # session.set_property('proxy-uri', proxy_uri) self._gtk = gtk self._gdk = gdk self._glib = glib self._libwebkit = libwebkit self._pid = multiprocessing.current_process().pid # self._plugs = dict((self._create_window(com_dict, com_pipe),)) # self._plugs = {} self._windows = [self._create_window(com_dict, com_pipe)]
def language_changed(self, buffer, language): language = buffer.get_language() if language is None: return lang_id = language.get_id() if lang_id == 'markdown': self.webview = WebKit2.WebView() buffer.connect('changed', self.changed) adjustment = self.scrolledwindow.get_vadjustment() adjustment.connect('changed', self.scrolled) adjustment.connect('value-changed', self.scrolled) box = self.scrolledwindow.get_parent() box.pack_end(self.webview, True, True, 0) self.webview.show_all() self.changed(buffer) else: self.do_deactivate()
def __init__(self, parent=None): self.accelerators = None Gtk.Dialog.__init__(self, _("Download Keyman keyboards"), parent) self.parentWindow = parent self.downloadfile = None init_accel(self) s = Gtk.ScrolledWindow() self.webview = WebKit2.WebView() self.webview.connect("decide-policy", self._keyman_policy) url = KeymanComUrl + "/go/linux/" + __releaseversion__ + "/download-keyboards" self.webview.load_uri(url) s.add(self.webview) self.get_content_area().pack_start(s, True, True, 0) self.add_button(_("_Close"), Gtk.ResponseType.CLOSE) if self.parentWindow is not None: self.getinfo = GetInfo(self.parentWindow.incomplete_kmp) self.resize(800, 450) self.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): Gtk.Window.__init__(self) self.set_default_size(400, 400) self.set_title('Sign into Reddit') self._state = str(uuid4()) ctx = WebKit2.WebContext.get_default() ctx.register_uri_scheme('redditgtk', self.__uri_scheme_cb) self._web = WebKit2.WebView() self._web.load_uri( 'https://www.reddit.com/api/v1/authorize.compact?{end}'. format(end=urllib.parse.urlencode( dict(redirect_uri='redditgtk://done', state=self._state, client_id='WCN3jqoJ1-0r0Q', response_type='code', duration='permanent', scope=( 'edit history identity mysubreddits privatemessages' ' submit subscribe vote read save'))))) self.add(self._web) self.show_all()
def __on_openall_clicked(self, action, variant): """ Add all entries @param Gio.SimpleAction @param GVariant """ for i in range(0, self.__closed_section.get_n_items()): uri_attr = self.__closed_section.get_item_attribute_value(i, "uri") if uri_attr is None: continue priv_attr = self.__closed_section.get_item_attribute_value( i, "private") state_attr = self.__closed_section.get_item_attribute_value( i, "state") if state_attr is not None: webkit_state = WebKit2.WebViewSessionState( GLib.Bytes.new(state_attr.get_string())) else: webkit_state = None GLib.idle_add(self.__app.active_window.container.add_webview, uri_attr.get_string(), Gdk.WindowType.OFFSCREEN, priv_attr.get_boolean(), None, webkit_state, False) self.__closed_section.remove(i)
def __init__(self): self.builder = Gtk.Builder() # Get UI self.builder.add_from_file(gladefile) self.builder.connect_signals(self) # ToolBar self.navbar = self.builder.get_object("navbar") self.last = self.builder.get_object("last") self.next = self.builder.get_object("next") self.menu = self.builder.get_object("menu") self.previous = self.builder.get_object("previous") # Scriptures self.scriptures = self.builder.get_object("scriptures") self.scriptures.connect('destroy', lambda w: Gtk.main_quit()) self.scrolledwindow = self.builder.get_object("scrolledwindow") self.scriptures.show_all() # Webkit self.webview = WebKit.WebView() self.scrolledwindow.add(self.webview) self.webview.load_uri('file://' + scriptures_dir + 'main-menu.html') self.webview.connect('notify::title', self.change_title) self.webview.connect('load-changed', self.change_current_url) self.webview.show()
def do_load(self, workbench): print('Builder Workbench Addin: Load Bracer plugin workbench') editor = workbench.get_perspective_by_name('editor') dock_pane = Ide.EditorPerspective.get_utilities(editor) dock_widget = Dazzle.DockWidget( title=_('Rust Docs'), icon_name='accessories-dictionary-symbolic', visible=True, expand=False) Bracer.dock_widget = dock_widget if Bracer.settings.get_boolean('prefs-documentation'): if Bracer.settings.get_boolean('prefs-markdown'): Bracer._MARKDOWN_CSS = Bracer.get_data( 'resources/markdown.css') Bracer._HL_GITHUB_CSS = Bracer.get_data('resources/github.css') Bracer._MARKED_JS = Bracer.get_data('resources/marked.js') Bracer._HL_JS = Bracer.get_data('resources/hljs.js') Bracer._MARKDOWN_VIEW_JS = Bracer.get_data( 'resources/markdown-view.js') webview = WebKit2.WebView(visible=True, expand=True) Bracer.dock_webview = webview settings = webview.get_settings() settings.enable_html5_local_storage = False Bracer.dock_widget.add(Bracer.dock_webview) Ide.LayoutPane.add(dock_pane, Bracer.dock_widget) else: dock_text_widget = Gtk.TextView(visible=True, expand=True) Bracer.dock_text_widget = dock_text_widget scrolled = Gtk.ScrolledWindow(visible=True) scrolled.add(Bracer.dock_text_widget) Bracer.dock_widget.add(scrolled) Ide.LayoutPane.add(dock_pane, Bracer.dock_widget)
def create_window(self): app_icon = GdkPixbuf.Pixbuf.new_from_file(sys.path[0] + '/images/icon.png') self.login_window = Gtk.Window( title="Games Nebula", type=Gtk.WindowType.TOPLEVEL, window_position=Gtk.WindowPosition.CENTER_ALWAYS, icon=app_icon, width_request=390, height_request=496, resizable=False) self.login_window.connect('delete-event', self.quit_app) self.setup_cookies() content_manager = self.new_content_manager() self.webpage = WebKit2.WebView(user_content_manager=content_manager) self.webpage.connect('load_changed', self.webpage_loaded) self.webpage_color = Gdk.RGBA( red=0.149019, green=0.149019, blue=0.149019, alpha=1.0, ) self.webpage.set_background_color(self.webpage_color) auth_url = get_auth_url() self.webpage.load_uri(auth_url) self.scrolled_window = Gtk.ScrolledWindow() self.scrolled_window.add(self.webpage) self.login_window.add(self.scrolled_window) self.login_window.show_all()
def __init__(self, parent): super(LyricWikiWindow, self).__init__(default_width=500, default_height=500, dialog=False) self.set_transient_for(parent) self._thread = SearchThread() self.connect("destroy", lambda *x: self._thread.stop()) sw = Gtk.ScrolledWindow() self.add(sw) self._view = view = WebKit2.WebView() settings = view.get_settings() # for the mobile version settings.set_property( "user-agent", ("Mozilla/5.0 (Linux; Android 5.1.1; Nexus 5 Build/LMY48B; wv) " "AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0" "Chrome/43.0.2357.65 Mobile Safari/537.36")) def scroll_tp_lyrics(view, load_event): if load_event != WebKit2.LoadEvent.COMMITTED: return view.run_javascript( """ document.addEventListener('DOMContentLoaded', function() { var box = document.getElementsByClassName('lyricbox')[0]; box.scrollIntoView(true); }, false); """, None, None, None) view.connect('load-changed', scroll_tp_lyrics) sw.add(view) sw.show_all()
def __init__(self, uri, html=None, verbose=False, cookies=None, verify=True): window = Gtk.Window() # API reference: https://lazka.github.io/pgi-docs/#WebKit2-4.0 self.closed = False self.success = False self.saml_result = {} self.verbose = verbose self.ctx = WebKit2.WebContext.get_default() if not args.verify: self.ctx.set_tls_errors_policy(WebKit2.TLSErrorsPolicy.IGNORE) self.cookies = self.ctx.get_cookie_manager() if args.cookies: self.cookies.set_accept_policy(WebKit2.CookieAcceptPolicy.ALWAYS) self.cookies.set_persistent_storage( args.cookies, WebKit2.CookiePersistentStorage.TEXT) self.wview = WebKit2.WebView() window.resize(500, 500) window.add(self.wview) window.show_all() window.set_title("SAML Login") window.connect('delete-event', self.close) self.wview.connect('load-changed', self.get_saml_headers) self.wview.connect('resource-load-started', self.log_resources) if html: self.wview.load_html(html, uri) else: self.wview.load_uri(uri)
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 __init__(self, mobile=True, private=True): """ Init view @param mobile as bool @param private as bool """ Gtk.Stack.__init__(self) self.connect('destroy', self._on_destroy) self.set_transition_duration(500) self.set_transition_type(Gtk.StackTransitionType.CROSSFADE) self._current = '' builder = Gtk.Builder() # Use ressource from ArtistContent builder.add_from_resource('/org/gnome/Lollypop/ArtistContent.ui') self._view = WebKit2.WebView() self.add_named(builder.get_object('spinner'), 'spinner') self.set_visible_child_name('spinner') self.add_named(self._view, 'view') self._view.connect('load-changed', self._on_load_changed) settings = self._view.get_settings() # Private browsing make duckduckgo fail to switch translations if private: settings.set_property('enable-private-browsing', True) settings.set_property('enable-plugins', False) if mobile: settings.set_property( 'user-agent', "Mozilla/5.0 (Linux; Ubuntu 14.04;" " BlackBerry) AppleWebKit2/537.36 Chromium" "/35.0.1870.2 Mobile Safari/537.36") self._view.set_settings(settings) # FIXME TLS is broken in WebKit2, don't know how to fix this self._view.get_context().set_tls_errors_policy( WebKit2.TLSErrorsPolicy.IGNORE) self._view.connect('decide_policy', self._on_decide_policy) self._view.set_property('hexpand', True) self._view.set_property('vexpand', True) self._view.show()
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 test(url: str = 'https://inbox.google.com'): from gi.repository import WebKit2 as libwebkit from gi.repository import Gtk as gtk from gi.repository import GLib as glib webview = libwebkit.WebView() settings = webview.get_settings() settings.set_property('user-agent', '''Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.106 Safari/537.36''') webview.load_uri(url) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.PolicyType.AUTOMATIC,gtk.PolicyType.AUTOMATIC) scroll.set_shadow_type(gtk.ShadowType.IN) window = gtk.Window() window.connect_after('destroy', gtk.main_quit) window.add(scroll) scroll.add(webview) window.show_all() gtk.main()
def __init__(self, config, parent): """ :param dict config: The King Phisher client configuration. :param parent: The parent window for this object. :type parent: :py:class:`Gtk.Window` """ self.label = Gtk.Label(label='Preview') """The :py:class:`Gtk.Label` representing this tabs name.""" self.config = config self.parent = parent self.box = Gtk.Box() self.box.set_property('orientation', Gtk.Orientation.VERTICAL) self.box.show() self.webview = WebKitX.WebView() """The :py:class:`WebKit2.WebView` object used to render the message HTML.""" if has_webkit2: self.webview.get_context().set_cache_model( WebKitX.CacheModel.DOCUMENT_VIEWER) self.webview.show() scrolled_window = Gtk.ScrolledWindow() scrolled_window.add(self.webview) scrolled_window.show() self.box.pack_start(scrolled_window, True, True, 0)
def __init__(self, url): self.code = None Gtk.Dialog.__init__(self) self.set_position(Gtk.WindowPosition.CENTER_ALWAYS) self.set_title(comun.APP) self.set_icon_from_file(comun.ICON) vbox = Gtk.VBox(spacing=5) self.get_content_area().add(vbox) hbox1 = Gtk.HBox() vbox.pack_start(hbox1, True, True, 0) self.scrolledwindow1 = Gtk.ScrolledWindow() self.scrolledwindow1.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self.scrolledwindow1.set_shadow_type(Gtk.ShadowType.IN) hbox1.pack_start(self.scrolledwindow1, True, True, 0) self.viewer = WebKit2.WebView() self.scrolledwindow1.add(self.viewer) self.scrolledwindow1.set_size_request(600, 630) self.viewer.connect('load-changed', self.load_changed) self.viewer.load_uri(url) self.show_all()
def __init__(self, data): Result.__init__(self) self.data = data self.html = data.replace('/nbextensions', '/usr/share/jupyter/nbextensions') self.content = WebKit2.WebView() self.content.get_settings().set_enable_webgl(True) self.content.set_size_request(750, -1) self.get_style_context().add_class('resulthtmlview') self.centerbox.set_center_widget(self.content) self.show_all() # observe result view self.content.connect('load-changed', self.on_load_changed) self.content.connect('context-menu', self.on_context_menu) self.content.connect('button-press-event', self.on_mouse_click) self.content.load_html( self.html, 'file://' + service_locator.ServiceLocator.get_base_path())
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')
# along with this program. If not, see <http://www.gnu.org/licenses/>. #Import nescessary libraries and modules #from gettext import gettext as _ from gi.repository import Gdk, Gio, Gtk, GLib, Handy, GObject, WebKit2, Pango from os import path, makedirs, listdir import locale import json import threading from copy import deepcopy from .fsync import async_function from time import sleep from urllib.request import urlretrieve, urlopen #Init Webkit and Handy libs Handy.init() WebKit2.WebView() locale.bindtextdomain( 'fontdownloader', path.join(path.dirname(__file__).split('fontdownloader')[0], 'locale')) locale.textdomain('fontdownloader') webfontsData = json.load( open( path.join( path.dirname(__file__).split('fontdownloader')[0], 'fontdownloader/fontdownloader/webfonts.json'), 'r')) SAMPLE_STRING = Pango.language_get_default().get_sample_string()
def __init__(self, window): BrowserView.instances[window.uid] = self self.uid = window.uid self.pywebview_window = window self.is_fullscreen = False self.js_results = {} glib.threads_init() self.window = gtk.Window(title=window.title) self.shown = window.shown self.loaded = window.loaded if window.resizable: self.window.set_size_request(window.min_size[0], window.min_size[1]) self.window.resize(window.initial_width, window.initial_height) else: self.window.set_size_request(window.initial_width, window.initial_height) if window.minimized: self.window.iconify() if window.initial_x is not None and window.initial_y is not None: self.move(window.initial_x, window.initial_y) else: self.window.set_position(gtk.WindowPosition.CENTER) self.window.set_resizable(window.resizable) # Set window background color style_provider = gtk.CssProvider() style_provider.load_from_data( 'GtkWindow {{ background-color: {}; }}'.format(window.background_color).encode() ) gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, gtk.STYLE_PROVIDER_PRIORITY_APPLICATION ) scrolled_window = gtk.ScrolledWindow() self.window.add(scrolled_window) if window.confirm_close: self.window.connect('delete-event', self.on_destroy) else: self.window.connect('delete-event', self.close_window) self.js_bridge = BrowserView.JSBridge(window) self.text_select = window.text_select self.webview = webkit.WebView() self.webview.connect('notify::visible', self.on_webview_ready) self.webview.connect('load_changed', self.on_load_finish) self.webview.connect('notify::title', self.on_title_change) self.webview.connect('decide-policy', self.on_navigation) user_agent = settings.get('user_agent') or _user_agent if user_agent: self.webview.get_settings().props.user_agent = user_agent if window.frameless: self.window.set_decorated(False) if window.easy_drag: self.move_progress = False self.webview.connect('button-release-event', self.on_mouse_release) self.webview.connect('button-press-event', self.on_mouse_press) self.window.connect('motion-notify-event', self.on_mouse_move) if window.on_top: self.window.set_keep_above(True) self.transparent = window.transparent if window.transparent: configure_transparency(self.window) configure_transparency(self.webview) wvbg = self.webview.get_background_color() wvbg.alpha = 0.0 self.webview.set_background_color(wvbg) if _debug: self.webview.get_settings().props.enable_developer_extras = True else: self.webview.connect('context-menu', lambda a,b,c,d: True) # Disable context menu self.webview.set_opacity(0.0) scrolled_window.add(self.webview) if window.real_url is not None: self.webview.load_uri(window.real_url) elif window.html: self.webview.load_html(window.html, '') else: self.webview.load_html(default_html, '') if window.fullscreen: self.toggle_fullscreen()
logger = logging.getLogger('pywebview') import gi gi.require_version('Gtk', '3.0') gi.require_version('Gdk', '3.0') gi.require_version('WebKit2', '4.0') from gi.repository import Gtk as gtk from gi.repository import Gdk from gi.repository import GLib as glib from gi.repository import WebKit2 as webkit # version of WebKit2 older than 2.2 does not support returning a result of javascript, so we # have to resort fetching a result via window title webkit_ver = webkit.get_major_version(), webkit.get_minor_version(), webkit.get_micro_version() old_webkit = webkit_ver[0] < 2 or webkit_ver[1] < 22 renderer = 'gtkwebkit2' settings = {} class BrowserView: instances = {} class JSBridge: def __init__(self, window): self.window = window self.uid = uuid1().hex[:8] def call(self, func_name, param, value_id):
#!/usr/bin/env python from gi.repository import WebKit2 version = '{}.{}.{}'.format(WebKit2.get_major_version(), WebKit2.get_minor_version(), WebKit2.get_micro_version()) user_agent = WebKit2.WebView().get_settings().get_user_agent() print('version = {}, user-agent = {}'.format(version, user_agent))
def __init__(self, kmpfile, online=False, viewkmp=None, downloadwindow=None): logging.debug("InstallKmpWindow: kmpfile: %s", kmpfile) self.kmpfile = kmpfile self.online = online self.endonclose = False self.viewwindow = viewkmp self.download = downloadwindow self.accelerators = None keyboardid = os.path.basename(os.path.splitext(kmpfile)[0]) installed_kmp_ver = get_kmp_version(keyboardid) if installed_kmp_ver: logging.info("installed kmp version %s", installed_kmp_ver) windowtitle = "Installing keyboard/package " + keyboardid Gtk.Window.__init__(self, title=windowtitle) init_accel(self) self.set_border_width(12) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=12) mainhbox = Gtk.Box() with tempfile.TemporaryDirectory() as tmpdirname: extract_kmp(kmpfile, tmpdirname) info, system, options, keyboards, files = get_metadata(tmpdirname) self.kbname = keyboards[0]['name'] self.checkcontinue = True if installed_kmp_ver: if info['version']['description'] == installed_kmp_ver: dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.QUESTION, Gtk.ButtonsType.YES_NO, "Keyboard is installed already") dialog.format_secondary_text( "The " + self.kbname + " keyboard is already installed at version " + installed_kmp_ver + ". Do you want to uninstall then reinstall it?") response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.YES: logging.debug("QUESTION dialog closed by clicking YES button") uninstall_kmp(keyboardid) elif response == Gtk.ResponseType.NO: logging.debug("QUESTION dialog closed by clicking NO button") self.checkcontinue = False else: try: logging.info("package version %s", info['version']['description']) logging.info("installed kmp version %s", installed_kmp_ver) if StrictVersion(info['version']['description']) <= StrictVersion(installed_kmp_ver): dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.QUESTION, Gtk.ButtonsType.YES_NO, "Keyboard is installed already") dialog.format_secondary_text( "The " + self.kbname + " keyboard is already installed with a newer version " + installed_kmp_ver + ". Do you want to uninstall it and install the older version" + info['version']['description'] + "?") response = dialog.run() dialog.destroy() if response == Gtk.ResponseType.YES: logging.debug("QUESTION dialog closed by clicking YES button") uninstall_kmp(keyboardid) elif response == Gtk.ResponseType.NO: logging.debug("QUESTION dialog closed by clicking NO button") self.checkcontinue = False except: logging.warning("Exception uninstalling an old kmp, continuing") pass image = Gtk.Image() if options and "graphicFile" in options: image.set_from_file(os.path.join(tmpdirname, options['graphicFile'])) else: img_default = find_keyman_image("defaultpackage.gif") image.set_from_file(img_default) mainhbox.pack_start(image, False, False, 0) self.page1 = Gtk.Box() self.page1.set_border_width(12) grid = Gtk.Grid() self.page1.add(grid) label1 = Gtk.Label() label1.set_text("Keyboard layouts: ") label1.set_halign(Gtk.Align.END) grid.add(label1) prevlabel = label1 label = Gtk.Label() keyboardlayout = "" for kb in keyboards: if keyboardlayout != "": keyboardlayout = keyboardlayout + "\n" keyboardlayout = keyboardlayout + kb['name'] label.set_text(keyboardlayout) label.set_halign(Gtk.Align.START) label.set_selectable(True) grid.attach_next_to(label, label1, Gtk.PositionType.RIGHT, 1, 1) fonts = get_fonts(files) if fonts: label2 = Gtk.Label() # Fonts are optional label2.set_text("Fonts: ") label2.set_halign(Gtk.Align.END) grid.attach_next_to(label2, prevlabel, Gtk.PositionType.BOTTOM, 1, 1) prevlabel = label2 label = Gtk.Label() fontlist = "" for font in fonts: if fontlist != "": fontlist = fontlist + "\n" if font['description'][:5] == "Font ": fontdesc = font['description'][5:] else: fontdesc = font['description'] fontlist = fontlist + fontdesc label.set_text(fontlist) label.set_halign(Gtk.Align.START) label.set_selectable(True) grid.attach_next_to(label, label2, Gtk.PositionType.RIGHT, 1, 1) label3 = Gtk.Label() label3.set_text("Package version: ") label3.set_halign(Gtk.Align.END) grid.attach_next_to(label3, prevlabel, Gtk.PositionType.BOTTOM, 1, 1) prevlabel = label3 label = Gtk.Label() label.set_text(info['version']['description']) label.set_halign(Gtk.Align.START) label.set_selectable(True) grid.attach_next_to(label, label3, Gtk.PositionType.RIGHT, 1, 1) if info and 'author' in info: label4 = Gtk.Label() label4.set_text("Author: ") label4.set_halign(Gtk.Align.END) grid.attach_next_to(label4, prevlabel, Gtk.PositionType.BOTTOM, 1, 1) prevlabel = label4 label = Gtk.Label() if 'url' in info['author']: label.set_markup("<a href=\"" + info['author']['url'] + "\" title=\"" + info['author']['url'] + "\">" + info['author']['description'] + "</a>") else: label.set_text(info['author']['description']) label.set_halign(Gtk.Align.START) label.set_selectable(True) grid.attach_next_to(label, label4, Gtk.PositionType.RIGHT, 1, 1) if info and 'website' in info: label5 = Gtk.Label() # Website is optional and may be a mailto for the author label5.set_text("Website: ") label5.set_halign(Gtk.Align.END) grid.attach_next_to(label5, prevlabel, Gtk.PositionType.BOTTOM, 1, 1) prevlabel = label5 label = Gtk.Label() label.set_markup("<a href=\"" + info['website']['description'] + "\">" + info['website']['description'] + "</a>") label.set_halign(Gtk.Align.START) label.set_selectable(True) grid.attach_next_to(label, label5, Gtk.PositionType.RIGHT, 1, 1) if info and 'copyright' in info: label6 = Gtk.Label() label6.set_text("Copyright: ") label6.set_halign(Gtk.Align.END) grid.attach_next_to(label6, prevlabel, Gtk.PositionType.BOTTOM, 1, 1) label = Gtk.Label() label.set_text(info['copyright']['description']) label.set_halign(Gtk.Align.START) label.set_selectable(True) grid.attach_next_to(label, label6, Gtk.PositionType.RIGHT, 1, 1) self.page2 = Gtk.Box() webview = WebKit2.WebView() webview.connect("decide-policy", self.doc_policy) if options and "readmeFile" in options: self.readme = options['readmeFile'] else: self.readme = "noreadme" readme_file = os.path.join(tmpdirname, self.readme) if os.path.isfile(readme_file): with open(readme_file, "r") as read_file: readme_data = read_file.read() readme_uri = pathlib.Path(readme_file).as_uri() logging.debug(readme_data) webview.load_html(readme_data, readme_uri) s = Gtk.ScrolledWindow() s.add(webview) self.page2.pack_start(s, True, True, 0) self.notebook = Gtk.Notebook() self.notebook.set_tab_pos(Gtk.PositionType.BOTTOM) mainhbox.pack_start(self.notebook, True, True, 0) self.notebook.append_page( self.page1, Gtk.Label('Details')) self.notebook.append_page( self.page2, Gtk.Label('README')) else: mainhbox.pack_start(self.page1, True, True, 0) vbox.pack_start(mainhbox, True, True, 0) hbox = Gtk.Box(spacing=6) vbox.pack_start(hbox, False, False, 0) button = Gtk.Button.new_with_mnemonic("_Install") button.connect("clicked", self.on_install_clicked) hbox.pack_start(button, False, False, 0) button = Gtk.Button.new_with_mnemonic("_Cancel") button.connect("clicked", self.on_cancel_clicked) hbox.pack_end(button, False, False, 0) bind_accelerator(self.accelerators, button, '<Control>w') self.add(vbox) self.resize(635, 270)
def unconfig_soup(self): """Load config values to a soup session""" soup_session = WebKit2.get_default_session() soup_session.disconnect(soup_session.request_queued_cid) self.unload_soup_cache(soup_session)
def __init__(self, *args, **kwargs): super(BrowserTab, self).__init__(*args, **kwargs) GObject.threads_init() Gdk.threads_init() self.toolbar = Gtk.Toolbar() self.user2_image = Gtk.Image() self.user2_image.set_from_file("library/png/user.png") self.user2_button = Gtk.ToolButton() self.user2_button.set_icon_widget(self.user2_image) self.user2_button.connect("clicked", self.user2) self.toolbar.insert(self.user2_button, 0) self.home_image = Gtk.Image() self.home_image.set_from_file("library/png/home_image.png") self.home_button = Gtk.ToolButton() self.home_button.set_icon_widget(self.home_image) self.home_button.connect("clicked", self.home_page) self.toolbar.insert(self.home_button, 1) self.back_image = Gtk.Image() self.back_image.set_from_file("library/png/back_image.png") self.back_button = Gtk.ToolButton() self.back_button.set_icon_widget(self.back_image) self.back_button.connect("clicked", self.go_back) self.toolbar.insert(self.back_button, 2) self.forward_image = Gtk.Image() self.forward_image.set_from_file("library/png/forward_image.png") self.forward_button = Gtk.ToolButton() self.forward_button.set_icon_widget(self.forward_image) self.forward_button.connect("clicked", self.go_forward) self.toolbar.insert(self.forward_button, 3) liststore = Gtk.ListStore(str) for item in [ "www.google.com.tr", "www.facebook.com", "www.facebook.com.tr", "www.google.com", "www.youtube.com.tr", "www.hurriyet.com.tr", "www.milliyet.com.tr", "www.twitter.com", "www.sahibinden.com", "www.eksisozluk.com", "www.sabah.com.tr", "www.haber7.com", "www.mynet.com", "www.r10.net", "yandex.com.tr", "www.wikipedia.org", "www.instagram.com", "www.oyunskor.com", "www.sozcu.com.tr", "www.ensonhaber.com", "www.haberturk.com", "www.gittigidiyor.com", "www.internethaber.com", "www.donanimhaber.com", "www.n11.com.tr", "www.haberler.com", "www.hepsiburada.com", "www.garanti.com.tr", "www.sporx.com", "www.linkedin.com.tr", "www.radikal.com.tr", "www.fanatik.com.tr", "www.uludagsozluk.com", "www.gazetevatan.com", "www.hurriyetemlak.com", "www.ntv.com.tr", "www.meb.gov.tr", "www.samanyolu.com", "www.wordpress.com", "www.yahoo.com", "www.cumhuriyet.com.tr", "www.msn.com", "www.imdb.com", "www.cnnturk.com", "www.hdfilmfullizle.com.tr", "www.tumblr.com", "www.shiftdelete.com", "www.dailymotion.com", "www.ntvspor.net", "www.acun.com.tr", "www.izlesene.com.tr", "www.amazon.com.tr", "www.akakce.com", "www.fotomac.com.tr", "www.tamindir.com" ]: liststore.append([item]) self.entrycompletion = Gtk.EntryCompletion() self.entrycompletion.set_model(liststore) self.entrycompletion.set_text_column(0) self.toolitem = Gtk.ToolItem() self.address_bar = Gtk.Entry() self.address_bar.connect("activate", self._load_url) self.address_bar.set_completion(self.entrycompletion) url2 = self.address_bar.get_text() self.address_bar.set_width_chars(95) self.address_bar_image = Gtk.Image() self.address_bar_image.set_from_file("library/png/go.png") self.address_bar_image2 = self.address_bar_image.get_pixbuf() self.address_bar.set_icon_from_pixbuf(Gtk.EntryIconPosition.SECONDARY, self.address_bar_image2) self.address_bar.connect("icon-press", self._load_url2) self.toolitem.add(self.address_bar) self.toolbar.insert(self.toolitem, 4) self.refresh_image = Gtk.Image() self.refresh_image.set_from_file("library/png/refresh_image.png") self.refresh_button = Gtk.ToolButton() self.refresh_button.set_icon_widget(self.refresh_image) self.refresh_button.connect("clicked", self.reload) self.toolbar.insert(self.refresh_button, 5) self.stop_image = Gtk.Image() self.stop_image.set_from_file("library/png/stop_image.png") self.stop_button = Gtk.ToolButton() self.stop_button.set_icon_widget(self.stop_image) self.stop_button.connect("clicked", self.stop_loading) self.toolbar.insert(self.stop_button, 6) self.toolitem2 = Gtk.ToolItem() self.search_bar = Gtk.Entry() self.search_bar.connect("activate", self.search2) self.search_bar.set_width_chars(30) self.toolitem2.add(self.search_bar) self.toolbar.insert(self.toolitem2, 7) self.download_image = Gtk.Image() self.download_image.set_from_file("library/png/download_image.png") self.download_button = Gtk.ToolButton() self.download_button.set_icon_widget(self.download_image) self.toolbar.insert(self.download_button, 8) self.preferences_menu_image = Gtk.Image() self.preferences_menu_image.set_from_file( "library/png/settings_image.png") self.preferences_menu_button = Gtk.ToolButton() self.preferences_menu_button.set_icon_widget( self.preferences_menu_image) self.preferences_menu_button.connect("clicked", self.app) self.toolbar.insert(self.preferences_menu_button, 9) self.toolbar.show_all() self.webview = WebKit2.WebView() self.websettings = self.webview.get_settings() self.find = self.webview.get_find_controller() sdf = self.webview.get_title() self.webview.connect("load-changed", self.control) self.webview.connect("enter-fullscreen", self.enterfullscreen) self.webview.connect("leave-fullscreen", self.leavefullscreen) self.webview.connect("notify::title", self.deneme1) self.webview.connect("notify::title", self.changed_url) self.webview.connect("load-failed", self.deneme3) self.show() self.scrolled_window = Gtk.ScrolledWindow() self.scrolled_window.add(self.webview) self.toolbar2 = Gtk.Toolbar() self.close_image = Gtk.Image() self.close_image.set_from_file("library/png/close_image.png") self.close_find_entry = Gtk.ToolButton() self.close_find_entry.set_icon_widget(self.close_image) self.close_find_entry.connect("clicked", self.toolbar2_hide) self.toolbar2.insert(self.close_find_entry, 0) self.toolitem2 = Gtk.ToolItem() self.find_bar = Gtk.Entry() self.find_bar.connect("activate", self.find2) self.find_bar.set_width_chars(35) self.toolitem2.add(self.find_bar) self.toolbar2.insert(self.toolitem2, 1) self.prev_image = Gtk.Image() self.prev_image.set_from_file("library/png/prev_image.png") self.prev_button = Gtk.ToolButton() self.prev_button.set_icon_widget(self.prev_image) self.prev_button.connect("clicked", self.find4) self.toolbar2.insert(self.prev_button, 2) self.next_image = Gtk.Image() self.next_image.set_from_file("library/png/next_image.png") self.next_button2 = Gtk.ToolButton() self.next_button2.set_icon_widget(self.next_image) self.next_button2.connect("clicked", self.find3) self.toolbar2.insert(self.next_button2, 3) self.toolbar4 = Gtk.Toolbar() self.close_image2 = Gtk.Image() self.close_image2.set_from_file("library/png/close2_image.png") self.close_find_entry2 = Gtk.ToolButton() self.close_find_entry2.set_icon_widget(self.close_image2) self.close_find_entry2.connect("clicked", self.toolbar4_hide) self.toolbar4.insert(self.close_find_entry2, 0) self.toolitem4 = Gtk.ToolItem() self.zoom_entry = Gtk.Entry() self.zoom_entry.connect("activate", self.zoom) self.zoom_entry.set_width_chars(15) zoom_level = self.webview.get_zoom_level() self.zoom_entry.set_text(str(zoom_level)) self.toolitem4.add(self.zoom_entry) self.toolbar4.insert(self.toolitem4, 1) self.zoom_minus_image = Gtk.Image() self.zoom_minus_image.set_from_file("library/png/minus_image.png") self.minus_button = Gtk.ToolButton() self.minus_button.set_icon_widget(self.zoom_minus_image) self.minus_button.connect("clicked", self.zoom_out) self.toolbar4.insert(self.minus_button, 2) self.zoom_plus_image = Gtk.Image() self.zoom_plus_image.set_from_file("library/png/plus_image.png") self.plus_button = Gtk.ToolButton() self.plus_button.set_icon_widget(self.zoom_plus_image) self.plus_button.connect("clicked", self.zoom_in) self.toolbar4.insert(self.plus_button, 3) self.zoom2 = Gtk.ToolButton() self.zoom2.set_label("Varsayılan görüntü") self.zoom2.connect("clicked", self.zoom3) self.toolbar4.insert(self.zoom2, 4) self.toolbar5 = Gtk.Toolbar() self.close_image4 = Gtk.Image() self.close_image4.set_from_file("library/png/close_image4.png") self.close_button = Gtk.ToolButton() self.close_button.set_icon_widget(self.close_image4) self.close_button.connect("clicked", self.app2) self.toolbar5.insert(self.close_button, 0) self.new_window_image = Gtk.Image() self.new_window_image.set_from_file("library/png/new_window_image.png") self.new_window_button = Gtk.ToolButton() self.new_window_button.set_icon_widget(self.new_window_image) self.new_window_button.connect("clicked", self.new_window) self.toolbar5.insert(self.new_window_button, 1) self.print_image = Gtk.Image() self.print_image.set_from_file("library/png/print_image.png") self.print_button = Gtk.ToolButton() self.print_button.set_icon_widget(self.print_image) self.print_button.connect("clicked", self.deneme) self.toolbar5.insert(self.print_button, 2) self.history_image = Gtk.Image() self.history_image.set_from_file("library/png/history_image.png") self.history_button = Gtk.ToolButton() self.history_button.set_icon_widget(self.history_image) self.history_button.connect("clicked", self.history2) self.toolbar5.insert(self.history_button, 3) self.fullscreen_image = Gtk.Image() self.fullscreen_image.set_from_file("library/png/fullscreen_image.png") self.fullscreen_button = Gtk.ToolButton() self.fullscreen_button.set_icon_widget(self.fullscreen_image) self.fullscreen_button.connect("clicked", self.fullscreen2) self.toolbar5.insert(self.fullscreen_button, 4) self.unfullscreen_image = Gtk.Image() self.unfullscreen_image.set_from_file( "library/png/unfullscreen_image.png") self.unfullscreen_button = Gtk.ToolButton() self.unfullscreen_button.set_icon_widget(self.unfullscreen_image) self.unfullscreen_button.connect("clicked", self.unfullscreen2) self.toolbar5.insert(self.unfullscreen_button, 5) self.find_image = Gtk.Image() self.find_image.set_from_file("library/png/find_image.png") self.find_button = Gtk.ToolButton() self.find_button.set_icon_widget(self.find_image) self.find_button.connect("clicked", self.find0) self.toolbar5.insert(self.find_button, 6) self.preferences_image = Gtk.Image() self.preferences_image.set_from_file( "library/png/preferences_image.png") self.preferences_button = Gtk.ToolButton() self.preferences_button.set_icon_widget(self.preferences_image) self.preferences_button.connect("clicked", self.preferences) self.toolbar5.insert(self.preferences_button, 7) self.developer_image = Gtk.Image() self.developer_image.set_from_file("library/png/developer_image.png") self.developer_button = Gtk.ToolButton() self.developer_button.set_icon_widget(self.developer_image) self.developer_button.connect("clicked", self.developer) self.toolbar5.insert(self.developer_button, 8) self.pack_start(self.toolbar, False, False, 0) self.pack_start(self.scrolled_window, True, True, 0) self.pack_start(self.toolbar4, False, False, 0) self.pack_start(self.toolbar2, False, False, 0) self.pack_start(self.toolbar5, False, False, 0) self.scrolled_window.show_all()
import inspect import os import gi from signal import signal, SIGINT, SIG_DFL from subprocess import Popen from sys import exit try: # python 3 from urllib.request import urlopen, pathname2url except ImportError: # python 2 from urllib import urlopen, pathname2url from webbrowser import open_new_tab from json import dumps as to_json gi.require_version('WebKit2', '4.0') from gi.repository import WebKit2, Gtk gi.require_version('Gtk', '3.0') window = Gtk.Window() webview = WebKit2.WebView() webview.load_uri( "https://s.tradingview.com/widgetembed/?frameElementId=tradingview_04652&symbol=OANDA%3ANAS100USD&interval=1&hidesidetoolbar=0&saveimage=0&toolbarbg=f1f3f6&studies=%5B%5D&hideideas=1&theme=White&style=1&timezone=Etc%2FUTC&studies_overrides=%7B%7D&overrides=%7B%7D&enabled_features=%5B%5D&disabled_features=%5B%5D&locale=en&utm_source=www.livecharts.co.uk&utm_medium=widget&utm_campaign=chart&utm_term=OANDA%3ANAS100USD" ) window.set_decorated(False) window.set_default_size(800, 600) window.add(webview) window.show_all() window.connect("destroy", Gtk.main_quit) Gtk.main()
def email_window(self, typ=None, email=None): # Empty defaults textview = None send_btn = None # Handle case for email having been selected if email: pprint(email) title = email['headers']['Subject'][0] if typ == 'Reply': title = 'Re: ' + title elif typ == 'Forward': title = 'Fw: ' + title else: title = 'New Email' email_win = Gtk.Dialog(parent=self.window, flags=Gtk.DialogFlags.MODAL, title=title) email_win.set_default_size(800, 500) box = email_win.get_content_area() box.set_spacing(5) toolbar = Gtk.Toolbar(icon_size=1) header_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5) if typ is not None or email is None: header_entries = {} # Build email header details view # Case: displaying selected email label_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) data_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) if email is not None and typ is None: headers = ['From', 'Subject', 'To'] label_width = len(max(headers, key=len)) + 5 for header in headers: header_label = Gtk.Label() header_label.set_markup( ('<b>' + header + ':</b>').ljust(label_width, ' ')) header_data = Gtk.Label(','.join( email['headers'][header]).replace('\n', ' ').replace('\r', '')) header_label.set_halign(Gtk.Align.START) header_data.set_halign(Gtk.Align.START) label_box.pack_start(header_label, False, False, 0) data_box.pack_start(header_data, False, False, 0) header_box.add(label_box) header_box.add(data_box) reply_btn = Gtk.ToolButton(label="_Reply", use_underline=True) reply_btn.connect('clicked', self.on_reply, email) forward_btn = Gtk.ToolButton(label="_Forward", use_underline=True) forward_btn.connect('clicked', self.on_forward, email) toolbar.insert(reply_btn, 0) toolbar.insert(forward_btn, 1) # Case: replying to selected email elif email is None or typ == 'Reply' or typ == 'Forward': headers = ['To', 'CC', 'BCC', 'Subject'] label_width = len(max(headers, key=len)) + 5 for header in headers: header_label = Gtk.Label() header_label.set_markup( ('<b>' + header + ':</b>').ljust(label_width, ' ')) header_entry = Gtk.Entry() if header == 'Subject': if typ is not None: pre = 'Re: ' if typ == 'Reply' else 'Fw: ' header_entry.set_text( pre + ','.join(email['headers'][header]).replace( '\n', ' ').replace('\r', '')) header_label.set_halign(Gtk.Align.START) header_entry.set_halign(Gtk.Align.START) header_entry.set_width_chars(150) header_entries[header] = header_entry label_box.pack_start(header_label, True, False, 0) data_box.pack_start(header_entry, True, False, 0) header_box.add(label_box) header_box.add(data_box) send_btn = Gtk.ToolButton(label="_Send", use_underline=True) toolbar.insert(send_btn, 0) # Add toolbar and header information view box.add(toolbar) box.add(header_box) # Build email display/edit area email_scroll = Gtk.ScrolledWindow() email_scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) # Set up email if this isn't a new email if email: webview = WebKit2.WebView() if typ in ['Reply', 'Forward']: webview.set_editable(True) for sub in email['body'].walk(): if not sub.is_multipart(): # Required workaround until the binding for load_bytes() is available # requires package only currently released for Ubuntu 15.04 (releases April 23, 2015) if sub.get_content_type() == 'text/html': webview.load_html(sub.get_payload(decode=True)) elif sub.get_content_type() == 'text/plain': msg = sub.get_payload(decode=True) if re.match(r'-----BEGIN PGP MESSAGE-----', msg): pw = passphrase_dialog(email_win) msg = gpg.decrypt_msg(msg, pw) zero_out(pw) webview.load_plain_text(msg) email_scroll.add(webview) else: textview = Gtk.TextView() email_scroll.add(textview) box.pack_start(email_scroll, True, True, 5) if send_btn: buf = textview.get_buffer() send_btn.connect('clicked', self.on_send, [header_entries, buf, email_win]) email_win.show_all()
def __init__(self, com_pipe: object, com_dict: object): """ Initialize the process. """ self._protocol_pat = re.compile( r'^(about:|http://|https://|ftp://|javascript:|mailto:|file://)', re.I) from gi.repository import Soup as libsoup from gi.repository import WebKit as libwebkit from gi.repository import Gtk as gtk from gi.repository import Gdk as gdk from gi.repository import GLib as glib from gi.repository import Pango as pango from gi.repository import Gio as gio from gi.repository import GdkPixbuf as gdkpixbuf self._gtk = gtk self._gdk = gdk self._glib = glib self._pango = pango self._webkit = libwebkit self._gio = gio self._gdkpixbuf = gdkpixbuf self._icon_db = libwebkit.get_favicon_database() self._accels = self._gtk.AccelGroup() accel_dict = { ('<Ctrl>t',): self._new_tab, ('<Ctrl>w',): self._close_tab, ('<Ctrl>l',): self._focus_address_entry, } for accel_tup, func in accel_dict.items(): for accel in accel_tup: keyval, modifier = self._gtk.accelerator_parse(accel) self._accels.connect(keyval, modifier, self._gtk.AccelFlags.VISIBLE, func) for i in range(9): self._accels.connect(self._gdk.keyval_from_name(str(i)), self._gdk.ModifierType.MOD1_MASK, self._gtk.AccelFlags.VISIBLE, self._switch_tab) self._window = self._gtk.Window() self._window.add_accel_group(self._accels) self._window.set_default_size(1024, 768) self._window.set_resizable(True) self._window.set_icon_name('web-browser') self._window.connect_after('delete-event', self._quit) self._tabs = self._gtk.Notebook() self._tabs.connect('page-reordered', self._tab_reordered) self._tabs.set_scrollable(True) self._tabs.set_show_tabs(True) self._window.add(self._tabs) self._window.show_all() self._pipe = com_pipe self._dict = com_dict self._windows = {} self._glib.io_add_watch(self._pipe.fileno(), self._glib.IO_IN, self._recieve)
def __init__(self, uri, icon=None, window_size='800x600', resizable=True, fullscreen=False, frameless=False, maximized=False, stylesheet_content="", script_content="", debug=False, external_links=False, parent=None): super(WebWindow, self).__init__(parent=parent) self.is_fullscreen = False self.initial_uri = uri self.script_content = script_content self.external_links = external_links self.set_border_width(0) width, height = list(map(int, window_size.split('x'))) self.set_default_size(width, height) self.set_resizable(resizable) if not resizable: self.set_size_request(width, height) if maximized: self.maximize() self.set_position(Gtk.WindowPosition.CENTER) if frameless: self.set_decorated(False) if icon: self.set_icon_from_file(icon) self.connect('delete-event', Gtk.main_quit) self.connect('key-press-event', self.on_key_press) self.connect('window-state-event', self.on_window_state_change) scrolled_window = Gtk.ScrolledWindow() self.add(scrolled_window) wdm = WebKit2.WebsiteDataManager( # local_storage_directory="ls" ) self.context = WebKit2.WebContext.new_with_website_data_manager(wdm) # self.context.set_additional_plugins_directory('plugins') if "http_proxy" in os.environ: proxy = WebKit2.NetworkProxySettings.new(os.environ["http_proxy"]) self.context.set_network_proxy_settings( WebKit2.NetworkProxyMode.CUSTOM, proxy) # WebKit2.CookieManager.set_persistent_storage( # self.context.get_cookie_manager(), # 'cookies', # WebKit2.CookiePersistentStorage(0), # ) self.webview = WebKit2.WebView.new_with_context(self.context) settings = self.webview.get_settings() settings.set_enable_plugins(False) settings.set_enable_webaudio(True) settings.set_enable_webgl(True) settings.set_enable_media_capabilities(True) settings.set_enable_media_stream(True) settings.set_enable_mediasource(True) settings.set_enable_accelerated_2d_canvas(True) settings.set_allow_file_access_from_file_urls(True) settings.set_enable_write_console_messages_to_stdout(True) settings.set_hardware_acceleration_policy( WebKit2.HardwareAccelerationPolicy.ALWAYS) if stylesheet_content: stylesheet = WebKit2.UserStyleSheet.new( stylesheet_content, WebKit2.UserContentInjectedFrames.TOP_FRAME, WebKit2.UserStyleLevel.USER, None, None) self.webview.get_user_content_manager().add_style_sheet(stylesheet) self.webview.connect("load-changed", self.on_navigation) self.webview.connect("notify::title", self.on_title_change) self.webview.connect("close", lambda ev: self.close()) self.webview.connect("decide-policy", self.on_decide_policy) scrolled_window.add(self.webview) # self.context.get_plugins(None, self.on_get_plugins) if debug: self.webview.get_settings().props.enable_developer_extras = True else: # self.webview.connect('context-menu', lambda a, b, c, d: True) # Disable context menu pass self.webview.load_uri(self.initial_uri) self.show_all() if fullscreen: self.fullscreen()
import os import sys from gi.repository import Gtk, Gdk from gi.repository import WebKit2 as WebKit webview = WebKit.WebView() path = "start.html" path = os.path.realpath(path) webview.load_uri("file://" + path) window = Gtk.Window() window.set_decorated(False) window.set_default_size(1, 1) window.add(webview) window.show_all() def quit(args): Gtk.main_quit() os.system("killall flask") window.connect("destroy", quit) Gtk.main()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.webview = WebKit2.WebView() self.add(self.webview) self.webview.load_uri(MATHPASTE_URL)