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)
