def test_global_context(self):
webView = WebKit2.WebView()
ctx = webView.get_javascript_global_context()
self.assertIsInstance(ctx, javascriptcore.JSContext)
self.assertIsInstance(ctx.globalObject, javascriptcore.JSObject)
self.assertTrue(ctx.evaluateScript("true"))
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.events.shown
self.loaded = window.events.loaded
self.localization = window.localization
self._last_width = window.initial_width
self._last_height = window.initial_height
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.window.connect('window-state-event', self.on_window_state_change)
self.window.connect('size-allocate', self.on_window_resize)
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['mode']:
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()
## Same thing here, the '.reload()' method is activated when the 'Refresh' button is clicked.
browserholder.reload()
def enterkey_clicked(self, button):
## To load the URL automatically when the "Enter" key is hit from the keyboard while focusing on the entry box, we have to use the '.load_uri()' method and grab the URL from the entry box.
browserholder.load_uri(urlentry.get_text())
## Nothing new here.. We just imported the 'ui.glade' file.
builder = Gtk.Builder()
builder.add_from_file("browser.glade")
builder.connect_signals(Handler())
window = builder.get_object("window1")
## Here's the new part.. We created a global object called 'browserholder' which will contain the WebKit rendering engine, and we set it to 'WebKit.WebView()' which is the default thing to do if you want to add a WebKit engine to your program.
browserholder = WebKit2.WebView()
## To disallow editing the webpage.
browserholder.set_editable(False)
## The default URL to be loaded, we used the 'load_uri()' method.
browserholder.load_uri("http://google.com")
urlentry = builder.get_object("entry1")
urlentry.set_text("https://www.google.com")
## Here we imported the scrolledwindow1 object from the ui.glade file.
scrolled_window = builder.get_object("scrolledwindow1")
## We used the '.add()' method to add the 'browserholder' object to the scrolled window, which contains our WebKit browser.
scrolled_window.add(browserholder)
unused_event, unused_hit_test_result):
# True will not show the menu
return True
resource_dir = 'usr/share/live-installer/'
glade_file = os.path.join(resource_dir, 'interface.ui')
builder = Gtk.Builder()
builder.add_from_file(glade_file)
# We have no significant browsing interface, so there isn't much point
# in WebKit creating a memory-hungry cache.
context = WebKit2.WebContext.get_default()
context.set_cache_model(WebKit2.CacheModel.DOCUMENT_VIEWER)
slideshow_path = "file:///usr/share/live-installer/slideshow/index.html"
webview = WebKit2.WebView()
s = webview.get_settings()
s.set_allow_file_access_from_file_urls(True)
webview.connect('context-menu', on_context_menu)
s.set_property('enable-caret-browsing', False)
webview.load_uri(slideshow_path)
webview.show()
builder.get_object("scrolled_slideshow").add(webview)
window = builder.get_object("main_window")
builder.get_object("notebook1").set_current_page(8)
window.show_all()
window.connect("destroy", Gtk.main_quit)
def create_page(self, widget, event):
overlay = Gtk.Overlay()
# Address bar
url_bar = Gtk.Entry()
url_bar.set_name("urlbar")
webview = WebKit2.WebView()
# History list for entry completion
liststore = Gtk.ListStore(str)
entrycompletion = Gtk.EntryCompletion()
entrycompletion.set_model(liststore)
entrycompletion.set_text_column(0)
# Stop loading web page and its event box
stop_image = Gtk.Image()
eventbox_stop = Gtk.EventBox()
vboxmain = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
vboxmain.set_name("boxbrowser")
view_boxbrowser = Gtk.Box()
screen_width, screen_height = screensize.get_screen_size()
webview.set_size_request(screen_width / 2, screen_height * 0.5)
webview.show()
view_boxbrowser.pack_start(webview, True, True, 0)
vboxmain.pack_end(view_boxbrowser, True, True, 0)
# Address box
address_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=2)
# web page backward button
backward_image = Gtk.Image()
backward_image.set_from_file(app_path + "/icons/icon-back.png")
eventbox_back = Gtk.EventBox()
eventbox_back.add(backward_image)
eventbox_back.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
eventbox_back.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
eventbox_back.set_tooltip_text("Go back")
# Webpage forward button
forward_image = Gtk.Image()
forward_image.set_from_file(app_path + "/icons/icon-next.png")
eventbox_next = Gtk.EventBox()
eventbox_next.add(forward_image)
eventbox_next.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
eventbox_next.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
eventbox_next.set_tooltip_text("Go forward")
# Stop loading page, button
stop_image.set_from_file(app_path + "/icons/icon-stop.png")
stop_image.show()
eventbox_stop.add(stop_image)
eventbox_stop.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
eventbox_stop.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
eventbox_stop.set_tooltip_text("Stop loading")
# Go button, load url
go_image = Gtk.Image()
go_image.set_from_file(app_path + "/icons/icon-go.png")
eventbox_go = Gtk.EventBox()
eventbox_go.add(go_image)
eventbox_go.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
eventbox_go.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
eventbox_go.set_tooltip_text("Load url")
#entry
self.append_liststore(liststore)
url_bar.set_completion(entrycompletion)
url_bar.set_placeholder_text("Enter address")
url_bar.connect("activate", self.load_url, stop_image, eventbox_stop,
webview)
# History button, to show history dialog
history_image = Gtk.Image()
history_image.set_from_file(app_path + "/icons/icon-history.png")
history_image.show()
eventbox_history = Gtk.EventBox()
eventbox_history.add(history_image)
eventbox_history.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
eventbox_history.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
eventbox_history.set_tooltip_text("Show history")
event_plus = Gtk.EventBox() # notebook tab close button
event_plus.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
event_plus.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
event_plus.set_tooltip_text("Open a new tab")
image_plus = Gtk.Image()
image_plus.set_from_file(app_path + "/icons/icon-plus.png")
event_plus.add(image_plus)
# Adding addressbox to its widgets
address_box.add(eventbox_back)
address_box.add(eventbox_next)
address_box.add(eventbox_stop)
address_box.pack_start(url_bar, True, True, 0)
address_box.add(eventbox_go)
address_box.add(eventbox_history)
address_box.add(event_plus)
# Address box to main box
vboxmain.add(address_box)
# webvew to main box
vboxmain.pack_start(view_boxbrowser, True, True, 0)
message_bar = MessageBar()
overlay.add(vboxmain)
overlay.add_overlay(message_bar)
# Notebokk tab box
box_tab = Gtk.HBox(spacing=8)
close_image = Gtk.Image()
close_image.set_from_file(app_path + "/icons/icon-close.png")
image_icon = Gtk.Image()
eventbox_close = Gtk.EventBox()
eventbox_close.set_name("eventboxclose")
eventbox_close.add(close_image)
eventbox_close.connect("enter-notify-event",
self.on_mouse_enter_button_icon)
eventbox_close.connect("leave-notify-event",
self.on_mouse_leave_button_icon)
label_title = Gtk.Label()
label_title.set_text("New tab")
box_tab.pack_start(image_icon, False, False, 0)
box_tab.pack_start(label_title, False, False, 0)
box_tab.pack_start(eventbox_close, False, False, 0)
box_tab.set_name("booktab")
box_tab.show_all()
overlay.show_all()
self.notebook.append_page(overlay, box_tab)
webview.connect("load-failed", webview.do_load_failed)
webview.connect("load-changed", self.on_load_changed, stop_image,
eventbox_stop, message_bar, image_icon)
webview.connect("resource_load_started", self.on_resource_load_started,
message_bar)
webview.connect('notify::title', self.change_title, label_title,
webview)
eventbox_back.connect("button_press_event", self.webview_goback,
webview)
eventbox_next.connect("button_press_event", self.webview_goforward,
webview)
eventbox_stop.connect("button_press_event", self.webview_stop_reload,
stop_image, webview, eventbox_stop, message_bar)
eventbox_go.connect("button_press_event", self.on_go_click, url_bar,
stop_image, eventbox_stop, webview)
eventbox_history.connect("button_press_event", self.show_history_page,
stop_image, eventbox_stop, webview, url_bar)
event_plus.connect("button_press_event", self.create_page)
eventbox_close.connect("button_press_event", self.close_tab)
# Show page newly added
self.notebook.set_current_page(self.notebook.get_n_pages() - 1)
self.notebook.show_all()
def _create_browser(self):
self.web_view = WebKit2.WebView()
self.pack_start(self.web_view, True, True, 0)
self.web_view.load_uri("file://" + self.last_uri)
def __init__(self):
self.url = re.compile(
'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
)
# create window
self.window = Gtk.Window()
self.window.connect('destroy', self.close)
self.window.set_default_size(360, 600)
self.window.set_icon_from_file(self.path('assets/halibut2.png'))
# Create navigation bar
self.navigation_bar = Gtk.HBox()
self.backimg = Gtk.Image.new_from_file(
"assets/back.png") #Make back icon
self.back = Gtk.ToolButton() # Make back button
self.back.set_icon_widget(self.backimg) # Bind the two
# make the foward button
self.fowardimg = Gtk.Image.new_from_file("assets/foward.png")
self.forward = Gtk.ToolButton()
self.forward.set_icon_widget(self.fowardimg)
# Make the reload button
self.refreshimg = Gtk.Image.new_from_file("assets/reload.png")
self.refresh = Gtk.ToolButton()
self.refresh.set_icon_widget(self.refreshimg)
# Make the home button
self.homeimg = Gtk.Image.new_from_file("assets/home.png")
self.home = Gtk.ToolButton()
self.home.set_icon_widget(self.homeimg)
# Make the search button
self.searchimg = Gtk.Image.new_from_file("assets/search.png")
self.search = Gtk.ToolButton()
self.search.set_icon_widget(self.searchimg)
# self.nexttabimg = Gtk.Image.new_from_file("assets/nexttab.png")
# self.nexttab = Gtk.ToolButton()
# self.nexttab.set_icon_widget(self.nexttabimg)
#This is the "tab back" button img
# self.lasttabimg = Gtk.Image.new_from_file("assets/tabback.png")
# self.lasttab = Gtk.ToolButton()
# self.lasttab.set_icon_widget(self.lasttabimg)
# self.closetabimg = Gtk.Image.new_from_file('assets/close.png')
# self.closetab = Gtk.ToolButton()
# self.closetab.set_icon_widget(self.closetabimg)
pixbufAn = GdkPixbuf.PixbufAnimation.new_from_file(
"assets/loading.gif")
self.loadimg = Gtk.Image()
self.loadimg.set_from_animation(pixbufAn)
# Make the address bar that you type the url in
self.tablbl = Gtk.Label()
self.address_bar = Gtk.Entry()
self.spinner = Gtk.Spinner()
self.address_bar.set_property("width-request",
100) # Define default sive
# Connect the buttons to their respective functions
self.back.connect('clicked', self.go_back) # Go back a page
self.forward.connect('clicked', self.go_forward) # go foward a page
self.refresh.connect('clicked', self.refresh_page) # Reload page
self.home.connect('clicked', self.go_home) # GO to home page
self.search.connect(
'clicked',
self.search_web) # search the text ing the uri bar on google.com
# self.nexttab.connect('clicked', self.next_tab) # go to the next tab
# self.lasttab.connect('clicked', self.back_tab) # go back a tab
# self.closetab.connect('clicked', self.close_tab)
self.address_bar.connect('activate', self.load_page)
self.window.connect('key-press-event', self.process_keypress)
# load the buttons into the app
# The False, False, 0 make the images work, but I don't why.
# I suspect black magic...
self.navigation_bar.pack_start(self.back, False, False, 0)
self.navigation_bar.pack_start(self.forward, False, False, 0)
self.navigation_bar.pack_start(self.refresh, False, False, 0)
self.navigation_bar.pack_start(self.home, False, False, 0)
self.navigation_bar.pack_start(self.search, False, False, 0)
self.navigation_bar.pack_start(self.address_bar, False, False, 0)
self.navigation_bar.pack_start(self.spinner, False, False, 0)
# self.navigation_bar.pack_start(self.closetab, False, False, 0)
# self.navigation_bar.pack_start(self.nexttab, False, False, 0)
self.navigation_bar.pack_start(self.tablbl, False, False, 0)
self.navigation_bar.pack_start(self.loadimg, False, False, 0)
# Create view for webpage
self.view = Gtk.ScrolledWindow()
self.webview = WebKit2.WebView()
self.go_home(None)
last_page = parse.get_pkg_attr('last: ', 'config')
self.webview.load_uri(last_page)
# self.webview.connect('title-changed', self.change_title)
# self.webview.connect('load-committed', self.change_url)
# self.webview.connect('download-requested', self.download_requested)
# self.webview.connect('mime-type-policy-decision-requested', self.policy_decision_requested)
self.view.add(self.webview)
# Add everything and initialize
self.container = Gtk.VBox()
self.container.pack_start(self.navigation_bar, False, False, 0)
self.container.pack_start(self.view, True, True, 0)
self.window.add(self.container)
self.window.set_default_size(800, 600)
self.tabs = []
self.pos = 0
self.window.show_all()
self.loadimg.hide()
try:
Gtk.main()
except KeyboardInterrupt or EOFError:
addr = self.address_bar.get_text()
parse.set_pkg_attr('last: ', addr, 'config')
Gtk.main_quit()
exit()
class ApplicationWindow(Gtk.ApplicationWindow):
__gtype_name__ = "FavaDesktopWindow"
stack = Gtk.Template.Child() # type: Gtk.Stack
placeholder_view = Gtk.Template.Child() # type: Gtk.Box
fava_icon = Gtk.Template.Child() # type: Gtk.Image
fava_view = Gtk.Template.Child() # type: Gtk.Box
search_bar = Gtk.Template.Child() # type: Gtk.SearchBar
# webkit workaround from https://stackoverflow.com/a/60128243
WebKit2.WebView()
webview = Gtk.Template.Child()
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 load_fava_icon(self):
"""Loads fava's icon from python package resources"""
loader = GdkPixbuf.PixbufLoader()
loader.write(
resources.read_text("fava_gtk", "placeholder_logo.svg").encode())
loader.close()
pixbuf = loader.get_pixbuf()
self.fava_icon.set_from_pixbuf(pixbuf)
def file_open(self, *args):
"""Shows the file open dialog and opens the requested beancount file"""
dialog = FileOpenDialog(transient_for=self)
response = dialog.run()
if response == Gtk.ResponseType.ACCEPT:
file = dialog.get_filename()
logger.info(f"User chose file {file}.")
self.server.start([file])
self.webview.load_uri(self.server.url)
self.stack.set_visible_child(self.fava_view)
self.search_action.set_enabled(True)
self.search_toggle_action.set_enabled(True)
def search_toggle(self, action: Gio.SimpleAction, state):
"""Toggles the search bar"""
if state:
self.search_start()
else:
self.search_stop()
def search_start(self, *args):
self.search_toggle_action.set_state(GLib.Variant.new_boolean(True))
self.search_bar.set_search_mode(True)
self.search_entry.select_region(0, -1)
self.search_entry.grab_focus()
@Gtk.Template.Callback("search_entry_search_changed_cb")
def search_changed(self, search_entry):
find_controller = self.webview.get_find_controller()
find_options = (WebKit2.FindOptions.CASE_INSENSITIVE
| WebKit2.FindOptions.WRAP_AROUND)
find_controller.search(self.search_entry.get_text(), find_options, 32)
@Gtk.Template.Callback("search_entry_previous_match_cb")
def search_previous(self, *args):
find_controller = self.webview.get_find_controller()
find_controller.search_previous()
@Gtk.Template.Callback("search_entry_next_match_cb")
def search_next_match(self, *args):
find_controller = self.webview.get_find_controller()
find_controller.search_next()
@Gtk.Template.Callback("search_entry_stop_search_cb")
def search_stop(self, *args):
self.search_toggle_action.set_state(GLib.Variant.new_boolean(False))
self.search_bar.set_search_mode(False)
find_controller = (self.webview.get_find_controller()
) # type: WebKit2.FindController
find_controller.search_finish()
self.search_entry.set_text("")
self.webview.grab_focus()
def close(self, *args):
"""Closes currently opened file, or closes the window if no file is open"""
if self.server.is_alive():
self.close_file()
else:
self.do_destroy()
def close_file(self, *args):
"""Closes the currently opened beancount file"""
self.search_stop()
self.search_action.set_enabled(False)
self.search_toggle_action.set_enabled(False)
self.stack.set_visible_child(self.placeholder_view)
self.server.stop()
def do_destroy(self):
"""Destroys the window, having first closed the file and stopped the server."""
self.close_file()
self.app.remove_window(self)
def build_thirdpane(self):
self.thirdpane_webview = WebKit2.WebView()
self.thirdpane_scrolled_window.add(self.thirdpane_webview)
# 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, environ
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, application, saved_state):
self.application = application
self.saved_state = saved_state
Gtk.ApplicationWindow.__init__(
self,
application=application,
icon_name="revolt",
role="main-window",
default_width=saved_state.get_uint("width"),
default_height=saved_state.get_uint("height"))
if self.saved_state.get_boolean("maximized"):
self.maximize()
self.saved_state.bind("maximized", self, "is-maximized",
Gio.SettingsBindFlags.SET)
if application.settings.get_boolean("use-header-bar"):
self.set_titlebar(self.__make_headerbar())
self.set_title(u"Revolt")
application.add_window(self)
self._webview = WebKit2.WebView(
user_content_manager=self._user_content_manager,
web_context=self._web_context)
self._webview.connect("decide-policy", self.__on_decide_policy)
self._webview.connect("context-menu", self.__on_context_menu)
application.settings.bind("zoom-factor", self._webview, "zoom-level",
Gio.SettingsBindFlags.GET)
if hasattr(self._webview, "set_maintains_back_forward_list"):
self._webview.set_maintains_back_forward_list(False)
websettings = self._webview.get_settings()
application.settings.bind("enable-developer-tools", websettings,
"enable-developer-extras",
Gio.SettingsBindFlags.GET)
application.settings.bind("enable-developer-tools", websettings,
"enable-write-console-messages-to-stdout",
Gio.SettingsBindFlags.GET)
self.add_accel_group(accelerators.window_keys)
websettings.set_allow_file_access_from_file_urls(True)
websettings.set_allow_modal_dialogs(False) # TODO
websettings.set_enable_fullscreen(False)
websettings.set_enable_java(False)
websettings.set_enable_media_stream(True)
websettings.set_enable_page_cache(False) # Single-page app
websettings.set_enable_plugins(False)
websettings.set_enable_smooth_scrolling(True)
websettings.set_enable_webaudio(True)
websettings.set_javascript_can_access_clipboard(True)
websettings.set_minimum_font_size(12) # TODO: Make it a setting
websettings.set_property("enable-mediasource", True)
# This makes Revolt lighter, and makes things work for people using
# binary drivers (i.e. NVidia) with Flatpak build. See issue #29.
if hasattr(websettings, "set_hardware_acceleration_policy"):
websettings.set_hardware_acceleration_policy(
WebKit2.HardwareAccelerationPolicy.NEVER)
self._webview.show_all()
self.add(self._webview)
self.__connect_widgets()
self.__notification_ids = set()
def __init__(self):
Gtk.ApplicationWindow.__init__(self)
self.set_title('GeoCaching Details')
self.set_default_size(400, 650)
self.set_icon_from_file(ICON_FILE)
mycache = json.loads(util.get_json_row(cacheid))
header = Gtk.HeaderBar(title=mycache['cachename'])
header.set_show_close_button(False)
self.set_titlebar(header)
button = Gtk.MenuButton()
header.pack_end(button)
menumodel = Gio.Menu()
menumodel.append("Log Visit", "win.log_visit")
menumodel.append("Open in Browser", "win.browser")
# menumodel.append("Quit", "win.quit")
button.set_menu_model(menumodel)
log_visit_action = Gio.SimpleAction.new("log_visit", None)
log_visit_action.connect("activate", self.log_visit_callback)
self.add_action(log_visit_action)
browser_action = Gio.SimpleAction.new("browser", None)
browser_action.connect("activate", self.browser_callback)
self.add_action(browser_action)
button = Gtk.Button(label="<")
button.connect("clicked", self.on_button_clicked)
header.pack_start(button)
grid1 = Gtk.Grid()
row = 0
mystr = "<big><b>" + mycache['cachename'] + "</b></big>"
row = self.add_grid_row("Cache Name:", mystr, grid1, row)
mystr = "<big>" + mycache['cachetype'] + "</big>"
row = self.add_grid_row("Cache Type:", mystr, grid1, row)
mystr = "<big>" + mycache['cachesize'] + "</big>"
row = self.add_grid_row("Cache Size:", mystr, grid1, row)
mystr = "<big>" + mycache['cacheid'] + "</big>"
row = self.add_grid_row("Cache ID:", mystr, grid1, row)
fwd_az = util.get_azimuth(lat, lon, mycache['lat'], mycache['lon'])
dist = util.distance_on_unit_sphere(lat, lon, mycache['lat'],
mycache['lon'])
mystr = "<big>" + str(int(round(dist * 1000, 0))) + "m @ " + \
str(int(round(fwd_az, 0))) + "°</big>"
row = self.add_grid_row("Distance:", mystr, grid1, row)
mystr = "<big>" + str(float(mycache['diff'])) + "/5.0</big>"
row = self.add_grid_row("Difficulty:", mystr, grid1, row)
mystr = "<big>" + str(float(mycache['terr'])) + "/5.0</big>"
row = self.add_grid_row("Terrain:", mystr, grid1, row)
mystr = "<big>" + mycache['cacheowner'] + "</big>"
row = self.add_grid_row("Owner:", mystr, grid1, row)
mystr = time.strftime('%d %b %Y', time.localtime(mycache['hidden']))
row = self.add_grid_row("Hidden:", mystr, grid1, row)
date = time.strftime('%d %b %Y', time.localtime(mycache['lastfound']))
mystr = "<big>" + date + "</big>"
row = self.add_grid_row("Last Found:", mystr, grid1, row)
mystr = util.from_decimal(mycache['lat'], 'lat') + " - " + \
util.from_decimal(mycache['lon'], 'lon')
row = self.add_grid_row("Cache Location:", mystr, grid1, row)
row = self.show_icons(grid1, row)
label = Gtk.Label()
label.set_halign(Gtk.Align.START)
label.set_hexpand(True)
agetext = util.stored_age(mycache['dltime'])
label.set_markup("Stored in Device: " + agetext)
grid1.attach(label, 0, row, 2, 1)
row += 1
logdesc = "<html><body>"
logdesc += mycache['short'] + mycache['body'] + "<br/>\n<br/>\n"
if mycache['hint'] != "":
logdesc += "<b><big>Hint:</big></b><br/>\n"
logdesc += "<div id='enc_hint' onClick='update()'>" + mycache[
'hint'] + "</div>"
logdesc += "<div id='dec_hint' onClick='update()' style='display:none'>"
logdesc += codecs.encode(mycache['hint'], 'rot_13') + "</div>"
logdesc += "<br/><br/>"
logdesc += """
<script type="text/javascript">
function update()
{
if(document.getElementById('enc_hint').style.display == '')
{
document.getElementById('enc_hint').style.display = 'none';
document.getElementById('dec_hint').style.display = '';
} else {
document.getElementById('enc_hint').style.display = '';
document.getElementById('dec_hint').style.display = 'none';
}
}
</script>
"""
logdesc += "</body></html>"
base_uri = "file:///"
webkit1 = WebKit2.WebView()
webkit1.load_html(logdesc, base_uri)
logs = util.get_html_logs(cacheid)
# print(logs)
self.webkit = WebKit2.WebView()
self.webkit.load_html(logs, base_uri)
self.notebook = Gtk.Notebook()
self.notebook.set_scrollable(True)
self.dlabel = Gtk.Label(label="Details")
self.desclabel = Gtk.Label(label="Description")
self.lblabel = Gtk.Label(label="Logbook")
self.notebook.append_page(grid1, self.dlabel)
self.notebook.append_page(webkit1, self.desclabel)
self.notebook.append_page(self.webkit, self.lblabel)
self.add(self.notebook)
def __init__(self):
# Build Window
self.window_main = Gtk.ApplicationWindow()
self.window_main.set_icon_name(app_icon_name)
self.window_main.set_title(app_title)
self.window_main.resize(1066, 600)
self.window_main.set_position(Gtk.WindowPosition.CENTER)
self.window_main.connect("delete-event", Gtk.main_quit)
# Build Header Bar
self.header_bar = Gtk.HeaderBar()
self.window_main.set_titlebar(self.header_bar)
self.header_bar.set_title(app_title)
self.header_bar.set_subtitle("Zero Features Browser")
self.header_bar.set_show_close_button(True)
self.header_bar.set_decoration_layout("menu:minimize,maximize,close")
# Build Header Button
self.header_button = Gtk.MenuButton()
self.header_bar.pack_end(self.header_button)
self.image_menu = Gtk.Image(icon_name="open-menu-symbolic")
self.header_button.set_image(self.image_menu)
self.header_button.set_tooltip_text("Menu")
# Build Main Menu
self.popover = Gtk.Popover()
self.header_button.set_popover(self.popover)
self.popover.set_position(Gtk.PositionType.BOTTOM)
self.popover_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
margin=3,
visible=True)
self.popover.add(self.popover_vbox)
# Menu Item Features
self.features_hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
visible=True)
self.features_image = Gtk.Image(icon_name="dialog-information",
visible=True)
self.features_button = Gtk.ModelButton(label="Features",
expand=True,
xalign=0,
visible=True)
self.features_button.connect("clicked", self.button_features_clicked)
self.features_hbox.pack_start(self.features_image, False, True, 0)
self.features_hbox.pack_start(self.features_button, False, True, 0)
self.popover_vbox.pack_start(self.features_hbox, False, True, 0)
# Menu Item About
self.about_hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
visible=True)
self.about_image = Gtk.Image(icon_name="help-about", visible=True)
self.about_button = Gtk.ModelButton(label="About",
expand=True,
xalign=0,
visible=True)
self.about_button.connect("clicked", self.button_about_clicked)
self.about_hbox.pack_start(self.about_image, False, True, 0)
self.about_hbox.pack_start(self.about_button, False, True, 0)
self.popover_vbox.pack_start(self.about_hbox, False, True, 0)
# Build Web View
self.webview = WebKit2.WebView()
self.window_main.add(self.webview)
self.webview.load_uri("https://www.duckduckgo.com"
) # Hardcoded home page. Is it a feature?
# Show window
self.window_main.show_all()
def build_ui(self):
self.gridMain = Gtk.Grid()
self.add(self.gridMain)
# Add the listbox in a scrolled window
self.swLB = Gtk.ScrolledWindow()
self.gridLB = Gtk.Grid()
self.gridLB.set_hexpand(True)
self.swLB.add(self.gridLB)
if bLBScrollWidth:
self.swLB.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
else:
self.swLB.set_policy(Gtk.PolicyType.NEVER,
Gtk.PolicyType.AUTOMATIC)
self.lbMain = Gtk.ListBox()
self.lbMain.set_hexpand(True)
#self.lbMain.set_vexpand(True)
self.lbLabel = Gtk.Label()
self.lbLabel.set_label("Vasudhaiva Kutumbakam")
self.lbLabel.set_hexpand(True)
self.lbLabel.set_halign(Gtk.Align.START)
self.gridLB.attach(self.lbMain, 0, 1, 1, 8)
self.gridLB.attach(self.lbLabel, 0, 0, 1, 1)
self.gridMain.attach(self.swLB, 1, 1, 4, 9)
self.update_lb()
self.lbMain.connect("row-activated", self.on_lb_row_activated)
self.lbMain.connect("button-release-event", self.on_lb_button_release)
# Added a separator
self.vSep = Gtk.VSeparator()
self.gridMain.attach(self.vSep, 5, 2, 1, 7)
# Add a WebView
self.wvMain = WebKit2.WebView()
self.wvMain.load_html(
"<html> <head><title> Browser </title></head> <body> <center> Satyameva Jayate </center> </body> </html>"
)
# Add the content views' scrolling window
self.swMain = Gtk.ScrolledWindow()
self.swMain.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.swMain.add(self.wvMain)
self.gridMain.attach(self.swMain, 6, 1, 9, 9)
# Add EvinceView
self.evMain = None
EvinceDocument.init()
self.evDoc = None
# Add the buttons
self.btnBase = Gtk.Button(label="Base")
self.btnBase.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnBase, 12, 10, 1, 1)
self.btnLast = Gtk.Button(label="Last")
self.btnLast.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnLast, 13, 10, 1, 1)
self.btnHide = Gtk.Button(label="[Un]Hide")
self.btnHide.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnHide, 14, 10, 1, 1)
self.btnUp = Gtk.Button(label="Up")
self.btnUp.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnUp, 6, 10, 1, 1)
self.btnPrev = Gtk.Button(label="Prev")
self.btnPrev.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnPrev, 7, 10, 1, 1)
self.btnPlay = Gtk.Button(label="Play")
self.btnPlay.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnPlay, 8, 10, 1, 1)
self.btnNext = Gtk.Button(label="Next")
self.btnNext.connect("clicked", self.on_btn_clicked)
self.gridMain.attach(self.btnNext, 9, 10, 1, 1)
def __init__(self, kmpfile, online=False, viewkmp=None, language=None):
logging.debug("InstallKmpWindow: kmpfile: %s", kmpfile)
self.kmpfile = kmpfile
self.online = online
self.viewwindow = viewkmp
self.accelerators = None
self.language = language
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}").format(
keyboardid=keyboardid)
Gtk.Dialog.__init__(self, windowtitle, viewkmp)
init_accel(self)
self.set_border_width(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(
viewkmp, 0, Gtk.MessageType.QUESTION,
Gtk.ButtonsType.YES_NO,
_("Keyboard is installed already"))
dialog.format_secondary_text(
_("The {name} keyboard is already installed at version {version}. "
"Do you want to uninstall then reinstall it?").
format(name=self.kbname, version=installed_kmp_ver))
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
return
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(
viewkmp, 0, Gtk.MessageType.QUESTION,
Gtk.ButtonsType.YES_NO,
_("Keyboard is installed already"))
dialog.format_secondary_text(
_("The {name} keyboard is already installed with a newer version {installedversion}. "
"Do you want to uninstall it and install the older version {version}?"
).format(
name=self.kbname,
installedversion=installed_kmp_ver,
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
return
except: # noqa: E722
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)
self.get_content_area().pack_start(mainhbox, True, True, 0)
hbox = Gtk.Box(spacing=6)
self.get_content_area().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.resize(800, 450)
self.show_all()
def __init__(self):
Gtk.ScrolledWindow.__init__(self)
self.browser = WebKit2.WebView()
self.add(self.browser)
class FontdownloaderWindow(Handy.Window):
__gtype_name__ = 'FontdownloaderWindow'
#Get settings schema
settings = Gio.Settings.new('org.gustavoperedo.FontDownloader')
#And here we import everything, basically
back_button = Gtk.Template.Child()
main_download_button = Gtk.Template.Child()
main_install_button = Gtk.Template.Child()
search_button = Gtk.Template.Child()
all_check = Gtk.Template.Child()
serif_check = Gtk.Template.Child()
sans_check = Gtk.Template.Child()
display_check = Gtk.Template.Child()
handwriting_check = Gtk.Template.Child()
mono_check = Gtk.Template.Child()
fonts_list = Gtk.Template.Child()
search_entry = Gtk.Template.Child()
search_bar = Gtk.Template.Child()
text_entry = Gtk.Template.Child()
font_preview = Gtk.Template.Child()
leaflet = Gtk.Template.Child()
box1 = Gtk.Template.Child()
box2 = Gtk.Template.Child()
about_button = Gtk.Template.Child()
headerbar1 = Gtk.Template.Child()
headerbar2 = Gtk.Template.Child()
light_mode_button = Gtk.Template.Child()
dark_mode_button = Gtk.Template.Child()
settings_button = Gtk.Template.Child()
SettingsWindow = Gtk.Template.Child()
close_settings_button = Gtk.Template.Child()
folder_settings_button = Gtk.Template.Child()
arabic_button = Gtk.Template.Child()
bengali_button = Gtk.Template.Child()
chinese_hk_button = Gtk.Template.Child()
chinese_SIMP_button = Gtk.Template.Child()
chinese_trad_button = Gtk.Template.Child()
cyrillic_button = Gtk.Template.Child()
cyrillic_ext_button = Gtk.Template.Child()
devanagari_button = Gtk.Template.Child()
greek_button = Gtk.Template.Child()
greek_ext_button = Gtk.Template.Child()
gujarati_button = Gtk.Template.Child()
gurmukhi_button = Gtk.Template.Child()
hebrew_button = Gtk.Template.Child()
japanese_button = Gtk.Template.Child()
kannada_button = Gtk.Template.Child()
khmer_button = Gtk.Template.Child()
korean_button = Gtk.Template.Child()
latin_button = Gtk.Template.Child()
latin_ext_button = Gtk.Template.Child()
malayalam_button = Gtk.Template.Child()
myanmar_button = Gtk.Template.Child()
oriya_button = Gtk.Template.Child()
sinhala_button = Gtk.Template.Child()
tamil_button = Gtk.Template.Child()
telugu_button = Gtk.Template.Child()
thai_button = Gtk.Template.Child()
tibetan_button = Gtk.Template.Child()
vietnamese_button = Gtk.Template.Child()
any_alphabet_button = Gtk.Template.Child()
reset_button = Gtk.Template.Child()
header_group = Gtk.Template.Child()
WebKit2.WebView()
#On initalization do:
def __init__(self, **kwargs):
super().__init__(**kwargs)
#Create a box for each font
for i in range(len(webfontsData['items'])):
self.newBox = FontBox(webfontsData['items'][i]['family'],
webfontsData['items'][i]['category'], i,
webfontsData['items'][i]['variants'],
webfontsData['items'][i]['subsets'])
#Make it visible and append it to our fonts panel
self.newBox.set_visible(True)
self.fonts_list.add(self.newBox)
#Select the first row and show all rows
self.fonts_list.select_row(self.fonts_list.get_row_at_index(0))
self.fonts_list.show()
#Creates temporary variables for our window
self.CurrentSelectedFont = ''
self.CurrentText = 'The quick brown fox jumps over the lazy dog.'
self.CurrentFilters = {
'serif': self.serif_check.get_active(),
'sans-serif': self.sans_check.get_active(),
'display': self.display_check.get_active(),
'handwriting': self.handwriting_check.get_active(),
'monospace': self.mono_check.get_active()
}
#Connect buttons, clicks, key presses to their functions
self.fonts_list.connect('row-activated', self.fontChanged)
self.text_entry.connect('changed', self.fontChanged)
self.back_button.connect('clicked', self.bringListForward)
self.main_download_button.connect('clicked', self.downloadFont)
self.main_install_button.connect('clicked', self.installFont)
self.search_button.connect('toggled', self.toggleSearch)
self.all_check.connect('toggled', self.checkAllFilters)
self.serif_check.connect('toggled', self.updateFilter)
self.sans_check.connect('toggled', self.updateFilter)
self.display_check.connect('toggled', self.updateFilter)
self.handwriting_check.connect('toggled', self.updateFilter)
self.mono_check.connect('toggled', self.updateFilter)
self.search_entry.connect('changed', self.updateFilter)
self.about_button.connect("clicked", self.on_about)
self.light_mode_button.connect('clicked', self.changeTheme)
self.dark_mode_button.connect('clicked', self.changeTheme)
self.settings_button.connect('clicked', self.presentSettings)
self.close_settings_button.connect('clicked', self.closeSettings)
self.folder_settings_button.connect('clicked', self.on_open)
self.any_alphabet_button.connect('clicked', self.anyAlphabet)
self.reset_button.connect('clicked', self.reset)
self.header_group.connect('update-decoration-layouts', self.updateSize)
self.alphabet_buttons = [
self.arabic_button, self.bengali_button, self.chinese_hk_button,
self.chinese_SIMP_button, self.chinese_trad_button,
self.cyrillic_button, self.cyrillic_ext_button,
self.devanagari_button, self.greek_button, self.greek_ext_button,
self.gujarati_button, self.gurmukhi_button, self.hebrew_button,
self.japanese_button, self.kannada_button, self.khmer_button,
self.korean_button, self.latin_button, self.latin_ext_button,
self.malayalam_button, self.myanmar_button, self.oriya_button,
self.sinhala_button, self.tamil_button, self.telugu_button,
self.thai_button, self.tibetan_button, self.vietnamese_button
]
self.alphabet_list = [
'arabic', 'bengali', 'chinese-hongkong', 'chinese-simplified',
'chinese-traditional', 'cyrillic', 'cyrillic-ext', 'devanagari',
'greek', 'greek-ext', 'gujarati', 'gurmukhi', 'hebrew', 'japanese',
'kannada', 'khmer', 'korean', 'latin', 'latin-ext', 'malayalam',
'myanmar', 'oriya', 'sinhala', 'tamil', 'telugu', 'thai',
'tibetan', 'vietnamese'
]
self.current_alphabet_list = self.settings.get_string(
'current-alphabet').split(';')
self.any_alphabet_button.set_active(
self.settings.get_boolean('any-alphabet'))
self.any_alphabet = self.any_alphabet_button.get_active()
for i in range(len(self.alphabet_list)):
if self.alphabet_list[i] in self.current_alphabet_list:
self.alphabet_buttons[i].set_active(True)
else:
self.alphabet_buttons[i].set_active(False)
self.anyAlphabet()
self.folder_settings_button.set_label(
_('Default') if self.settings.get_string('default-directory') ==
'Default' else self.settings.get_string('default-directory'))
for buttons in self.alphabet_buttons:
buttons.connect("toggled", self.updateAlphabet)
#Calls fontChanged function to update first view
self.fontChanged()
self.dark_mode_button.set_active(
self.settings.get_boolean('dark-mode'))
self.changeTheme()
#Sets up borders
self.setup_css()
self.checkForInstalledFonts()
@property
def folded(self):
self.fontChanged()
#About dialog, courtesy of GeorgesStavracas
def on_about(self, *args, **kwargs):
authors = ['Gustavo Machado Peredo', 'Georges Basile Stavracas Neto']
translators = ['Gustavo Machado Peredo', 'Victor Ibragimov']
dialog = Gtk.AboutDialog(transient_for=self, modal=True)
dialog.props.authors = authors
dialog.add_credit_section(_("Translators"), translators)
dialog.props.copyright = 'Copyright \xa9 2020 Gustavo Peredo'
dialog.props.license_type = Gtk.License.GPL_3_0
dialog.props.logo_icon_name = 'org.gustavoperedo.FontDownloader'
dialog.props.program_name = _('Font Downloader')
dialog.present()
def setup_css(self, *args, **kwargs):
#Setup the CSS and load it.
uri = 'resource:///org/gustavoperedo/FontDownloader/style.css'
provider_file = Gio.File.new_for_uri(uri)
provider = Gtk.CssProvider()
provider.load_from_file(provider_file)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
def installFont(self, *args, **kwargs):
#This function gets the selected font's link and downloads
#to the '.local/share/fonts' directory
links = webfontsData['items'][
self.fonts_list.get_selected_row().get_index()]['files']
absolutePath = path.join(
path.expanduser('~'),
'.local/share/fonts') if self.settings.get_string(
'default-directory'
) == 'Default' else self.settings.get_string('default-directory')
if not path.exists(absolutePath):
makedirs(absolutePath)
for key in links:
urlretrieve(
links[key],
path.join(
absolutePath,
self.CurrentSelectedFont + " " + key + links[key][-4:]))
self.checkForInstalledFonts()
def downloadFont(self, *args, **kwargs):
#This function gets the selected font's link and downloads
#to the user's download directory
links = webfontsData['items'][
self.fonts_list.get_selected_row().get_index()]['files']
dialog = Gtk.FileChooserDialog(
"Please choose a folder", self,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
response = dialog.run()
if response == Gtk.ResponseType.OK:
absolutePath = dialog.get_filename()
if not path.exists(absolutePath):
makedirs(absolutePath)
for key in links:
urlretrieve(
links[key],
path.join(
absolutePath, self.CurrentSelectedFont + " " + key +
links[key][-4:]))
elif response == Gtk.ResponseType.CANCEL:
pass
dialog.destroy()
def checkAllFilters(self, *args, **kwargs):
#If the user select "All" on filters, check all
isAll = self.all_check.get_active()
self.serif_check.set_active(isAll)
self.sans_check.set_active(isAll)
self.display_check.set_active(isAll)
self.handwriting_check.set_active(isAll)
self.mono_check.set_active(isAll)
self.updateFilter()
def updateFilter(self, *args, **kwargs):
#Updates the fonts list's filter
self.fonts_list.set_filter_func(self.filterFonts, None, True)
def filterFonts(self, row, data, notifyDestroy):
#Where the actual filter happens, if it returns True, the row appears
#otherwise disappears
self.CurrentFilters = {
'serif': self.serif_check.get_active(),
'sans-serif': self.sans_check.get_active(),
'display': self.display_check.get_active(),
'handwriting': self.handwriting_check.get_active(),
'monospace': self.mono_check.get_active()
}
filtered = [
filters for filters in self.CurrentFilters
if self.CurrentFilters[filters]
]
searchBarText = self.search_entry.get_text().lower()
if not self.any_alphabet:
if any(i in self.current_alphabet_list
for i in row.get_child().data[3]):
return (
(searchBarText
== row.get_child().data[0][:len(searchBarText)].lower())
and (row.get_child().data[1] in filtered))
else:
return False
else:
return ((searchBarText
== row.get_child().data[0][:len(searchBarText)].lower())
and (row.get_child().data[1] in filtered))
def fontChanged(self, *args, **kwargs):
#Whenever the user does something that should change the font preview:
#We colect the data from the selected font
self.temp_data = self.fonts_list.get_selected_row().get_child().data
#The variable CurrentSelectedFont carries the font name
self.CurrentSelectedFont = self.temp_data[0]
#Get the text from the text entry
self.CurrentText = self.text_entry.get_text()
if self.CurrentText == "":
self.CurrentText = "The quick brown fox jumps over the lazy dog."
#Creates a html file with everything (font and text, basically) :P
self.html = """
<!DOCTYPE html>
<html>
<style>
body {
overflow-wrap: break-word;
background-color: white;
font-family: '""" + self.CurrentSelectedFont + """';
}
@media(prefers-color-scheme: dark) {
body {
background-color: #353535;
color: #ffffff;
}
}
</style>
<link href="https://fonts.googleapis.com/css2?family=""" + self.CurrentSelectedFont.replace(
' ', '+') + """&display=swap" rel="stylesheet">
<body>
<h1> """ + self.CurrentText + """ </h1>
<h2> """ + self.CurrentText + """ </h2>
<h3> """ + self.CurrentText + """ </h3>
<h4> """ + self.CurrentText + """ </h4>
<p> """ + self.CurrentText + """ </p>
</body>
</html>
"""
#Load the html, set title and subtitle
self.font_preview.load_html(self.html)
self.headerbar2.set_title(self.CurrentSelectedFont)
self.headerbar2.set_subtitle(
_('sans-serif') if self.temp_data[1] == 'sans-serif' else (
_('serif') if self.temp_data[1] == 'serif' else (
_('display') if self.temp_data[1] == 'display' else (
_('monospaced') if self.temp_data[1] ==
'monospace' else _('handwriting')))))
self.leaflet.set_visible_child(self.box2)
def updateSize(self, *args, **kwargs):
#If the screen is too small, change to font preview pane and show
#the return button, otherwise, do the opposite
if self.leaflet.get_folded():
self.back_button.show()
self.main_download_button.set_label('')
#self.leaflet.set_visible_child(self.box2)
else:
self.bringListForward()
#Turns search on or off
def toggleSearch(self, *args, **kwargs):
self.search_bar.set_search_mode(not self.search_bar.get_search_mode())
#If the user press back_button, return focus to list view
def bringListForward(self, *args, **kwargs):
self.leaflet.set_visible_child(self.box1)
self.main_download_button.set_label(_('Download'))
self.back_button.hide()
def changeTheme(self, *args, **kwargs):
if self.dark_mode_button.get_active():
Gtk.Settings.get_default().set_property(
'gtk-application-prefer-dark-theme', True)
self.settings.set_boolean('dark-mode', True)
else:
Gtk.Settings.get_default().set_property(
'gtk-application-prefer-dark-theme', False)
self.settings.set_boolean('dark-mode', False)
def presentSettings(self, *args, **kwargs):
self.SettingsWindow.show()
def closeSettings(self, *args, **kwargs):
self.SettingsWindow.hide()
def on_open(self, event):
dialog = Gtk.FileChooserDialog(
_("Please choose a folder"), self,
Gtk.FileChooserAction.SELECT_FOLDER,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OPEN,
Gtk.ResponseType.OK))
response = dialog.run()
if response == Gtk.ResponseType.OK:
file_path = dialog.get_filename()
self.folder_settings_button.set_label(file_path)
self.settings.set_string('default-directory', file_path)
elif response == Gtk.ResponseType.CANCEL:
pass
dialog.destroy()
def updateAlphabet(self, *args, **kwargs):
self.current_alphabet_list = []
for i in range(len(self.alphabet_list)):
if self.any_alphabet:
self.alphabet_buttons[i].set_active(self.any_alphabet)
elif self.alphabet_buttons[i].get_active():
self.current_alphabet_list.append(self.alphabet_list[i])
self.settings.set_string('current-alphabet',
';'.join(self.current_alphabet_list))
self.updateFilter()
def anyAlphabet(self, *args, **kwargs):
self.any_alphabet = self.any_alphabet_button.get_active()
if self.any_alphabet:
for i in range(len(self.alphabet_list)):
self.alphabet_buttons[i].set_active(self.any_alphabet)
self.settings.set_boolean('any-alphabet', self.any_alphabet)
self.updateAlphabet()
def reset(self, *args, **kwargs):
self.settings.set_string('default-directory', 'Default')
self.folder_settings_button.set_label('Default')
self.any_alphabet_button.set_active(True)
self.updateAlphabet()
def checkForInstalledFonts(self, *args, **kwargs):
defaultPath = path.join(
path.expanduser('~'),
'.local/share/fonts') if self.settings.get_string(
'default-directory'
) == 'Default' else self.settings.get_string('default-directory')
if not path.exists(defaultPath):
makedirs(defaultPath)
onlyfiles = [
f for f in listdir(defaultPath)
if path.isfile(path.join(defaultPath, f))
]
getrows = []
for i in webfontsData['items']:
getrows.append(i['family'])
for i in getrows:
for j in onlyfiles:
if i in j[:len(j[:-4])]:
self.fonts_list.get_row_at_index(
getrows.index(i)).get_child().installed_box.show()
def __init__(self, handle):
"""Set up the Words activity."""
activity.Activity.__init__(self, handle)
self._dictd_data_dir = './dictd/'
self._dictionaries = dictdmodel.Dictionaries(self._dictd_data_dir)
self._origin_languages = self._dictionaries.get_all_languages_origin()
self._origin_lang_options = {}
for lang in self._origin_languages:
self._origin_lang_options[lang] = dictdmodel.lang_codes[lang]
self.max_participants = 1
toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
toolbar_box.toolbar.set_style(Gtk.ToolbarStyle.BOTH_HORIZ)
activity_button.show()
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
from_toolitem = Gtk.ToolItem()
from_toolitem.add(Gtk.Label(_('From:')))
from_toolitem.show_all()
toolbar_box.toolbar.insert(from_toolitem, -1)
if 'origin' in self.metadata:
origin = self.metadata['origin']
else:
origin = 'eng'
if 'destination' in self.metadata:
destination = self.metadata['destination']
else:
destination = 'spa'
if 'searches' in self.metadata:
self._searches = json.loads(self.metadata['searches'])
else:
self._searches = {}
# Initial values | Valores iniciales
self.origin_lang = origin
self.destination_lang = destination
self._dictionary = dictdmodel.Dictionary(self._dictd_data_dir,
self.origin_lang,
self.destination_lang)
self._autosearch_timer = None
self._english_dictionary = None
self._alert = ErrorAlert()
self._alert.props.title = _('Wait...')
self._alert.props.msg = _('Loading dictionary data')
self.add_alert(self._alert)
self._alert.connect('response', self._alert_cancel_cb)
self._alert.show()
GObject.idle_add(self._init_english_dictionary)
self._last_word_translated = None
self._from_button = FilterToolItem('go-down', origin,
self._origin_lang_options)
self._from_button.connect("changed", self.__from_language_changed_cb)
toolbar_box.toolbar.insert(self._from_button, -1)
to_toolitem = Gtk.ToolItem()
to_toolitem.add(Gtk.Label(' ' + _('To:')))
to_toolitem.show_all()
toolbar_box.toolbar.insert(to_toolitem, -1)
self._init_destination_language()
self._to_button = FilterToolItem('go-down', self.destination_lang,
self._destination_lang_options)
self._to_button.connect("changed", self.__to_language_changed_cb)
toolbar_box.toolbar.insert(self._to_button, -1)
separator = Gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
font_size = int(style.FONT_SIZE * 1.5)
font = Pango.FontDescription("Sans %d" % font_size)
# This box will change the orientaion when the screen rotates
self._big_box = Gtk.Box(Gtk.Orientation.HORIZONTAL)
self._big_box.set_homogeneous(True)
self._big_box.set_margin_top(style.DEFAULT_SPACING)
self._big_box.set_margin_bottom(style.DEFAULT_SPACING)
lang1_container = Gtk.Grid()
lang1_container.set_row_spacing(style.DEFAULT_SPACING)
lang1_container.set_border_width(style.DEFAULT_SPACING)
lang1_round_box = RoundBox()
lang1_round_box.background_color = style.COLOR_BUTTON_GREY
lang1_round_box.border_color = style.COLOR_BUTTON_GREY
lang1_round_box.pack_start(lang1_container, True, True,
style.DEFAULT_SPACING)
self._big_box.pack_start(lang1_round_box, True, True, 0)
# Labels
label1 = Gtk.Label()
label1.set_markup('<span font="%d" color="white">%s</span>' %
(font_size, _("Word")))
label1.set_halign(Gtk.Align.START)
lang1_container.attach(label1, 0, 0, 1, 1)
speak1 = Gtk.ToolButton()
speak1.set_icon_widget(Icon(icon_name='microphone'))
speak1.set_halign(Gtk.Align.END)
speak1.connect("clicked", self.__speak_word_cb)
lang1_container.attach(speak1, 1, 0, 1, 1)
# Text entry box to enter word to be translated
self.totranslate = iconentry.IconEntry()
self.totranslate.set_icon_from_name(iconentry.ICON_ENTRY_PRIMARY,
'entry-search')
# self.search_entry.set_placeholder_text(text)
self.totranslate.add_clear_button()
self.totranslate.connect('activate', self.__totranslate_activated_cb)
self._totranslate_changed_id = self.totranslate.connect(
"changed", self.__totranslate_changed_cb)
self.totranslate.modify_font(font)
self.totranslate.set_hexpand(True)
lang1_container.attach(self.totranslate, 0, 1, 2, 1)
label1 = Gtk.Label()
label1.set_markup('<span font="%d" color="white">%s</span>' %
(font_size, _("Suggestions")))
label1.set_halign(Gtk.Align.START)
lang1_container.attach(label1, 0, 2, 2, 1)
# The "lang1" treeview box
self._suggestions_model = Gtk.ListStore(str)
suggest_treeview = Gtk.TreeView(self._suggestions_model)
suggest_treeview.modify_font(font)
suggest_treeview.set_enable_search(False)
suggest_treeview.set_headers_visible(False)
lang1cell = Gtk.CellRendererText()
lang1cell.props.ellipsize_set = True
lang1cell.props.ellipsize = Pango.EllipsizeMode.END
lang1treecol = Gtk.TreeViewColumn("", lang1cell, text=0)
self._suggestion_changed_cb_id = suggest_treeview.connect(
'cursor-changed', self.__suggestion_selected_cb)
suggest_treeview.append_column(lang1treecol)
scroll = Gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.add(suggest_treeview)
scroll.set_vexpand(True)
lang1_container.attach(scroll, 0, 3, 2, 1)
# This container have the result data
result_container = Gtk.Grid()
result_container.set_row_spacing(style.DEFAULT_SPACING)
result_container.set_border_width(style.DEFAULT_SPACING)
lang2_round_box = RoundBox()
lang2_round_box.background_color = style.COLOR_BUTTON_GREY
lang2_round_box.border_color = style.COLOR_BUTTON_GREY
lang2_round_box.pack_start(result_container, True, True,
style.DEFAULT_SPACING)
self._big_box.pack_start(lang2_round_box, True, True, 0)
# Text entry box to receive word translated
label = Gtk.Label()
label.set_markup('<span font="%d" color="white">%s</span>' %
(font_size, _("Translation")))
label.set_halign(Gtk.Align.START)
result_container.attach(label, 0, 0, 1, 1)
speak2 = Gtk.ToolButton()
speak2.set_icon_widget(Icon(icon_name='microphone'))
speak2.set_halign(Gtk.Align.END)
speak2.connect("clicked", self.__speak_translation_cb)
result_container.attach(speak2, 1, 0, 1, 1)
self.translated = Gtk.TextView()
self.translated.modify_font(font)
self.translated.set_buffer(Gtk.TextBuffer())
self.translated.set_left_margin(style.DEFAULT_PADDING)
self.translated.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
self.translated.set_editable(False)
self.translated.modify_bg(Gtk.StateType.NORMAL,
style.COLOR_TEXT_FIELD_GREY.get_gdk_color())
self.translated.modify_bg(Gtk.StateType.SELECTED,
style.COLOR_SELECTION_GREY.get_gdk_color())
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.add(self.translated)
scrolled.set_hexpand(True)
scrolled.set_size_request(-1, style.GRID_CELL_SIZE * 2)
result_container.attach(scrolled, 0, 1, 2, 1)
label = Gtk.Label()
label.set_markup('<span font="%d" color="white">%s</span>' %
(font_size, _("Dictionary")))
label.set_halign(Gtk.Align.START)
result_container.attach(label, 0, 2, 1, 1)
speak2 = Gtk.ToolButton()
speak2.set_icon_widget(Icon(icon_name='microphone'))
speak2.set_halign(Gtk.Align.END)
speak2.connect("clicked", self.__speak_dictionary_cb)
result_container.attach(speak2, 1, 2, 1, 1)
self.dictionary = WebKit.WebView()
self.dictionary.load_html(EMPTY_HTML, 'file:///')
self.dictionary.set_zoom_level(0.75)
# Removes right-click context menu
self.dictionary.connect("button-press-event",
lambda w, e: e.button == 3)
scrolled = Gtk.ScrolledWindow()
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
scrolled.add(self.dictionary)
scrolled.set_hexpand(True)
scrolled.set_vexpand(True)
result_container.attach(scrolled, 0, 3, 2, 1)
self._big_box.show_all()
self.set_canvas(self._big_box)
self.totranslate.grab_focus()
self.show_all()
def __init__(self):
Gtk.EventBox.__init__(self)
self.set_valign(Gtk.Align.START)
self.set_halign(Gtk.Align.START)
self.html_skel='<html><body bgcolor=black><div align=center><iframe height=97% width=90% align=center src="%%URL%%" frameborder="0" allowfullscreen></iframe></div></body></html>'
self.border=20
try:
cache_dir=os.environ["XDG_CACHE_HOME"]
except:
cache_dir=os.path.expanduser("~/.cache/")
self.image_dir=cache_dir+"/lliurex-store/"
self.revealer=Gtk.Revealer()
self.revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_DOWN)
self.revealer.set_transition_duration(500)
self.content_box=Gtk.VBox()
self.content_box.set_name("POPUP_SHADOW_TOPBOTTOM")
hbox=Gtk.HBox()
self.image=Screenshot.ScreenshotNeo()
self.wv=WebKit.WebView()
self.wv=WebKit.WebView()
self.w_vp=Gtk.Viewport()
self.w_sw=Gtk.ScrolledWindow()
self.w_vp.add(self.w_sw)
self.w_sw.add(self.wv)
self.image.add_titled(self.w_vp,"html","Html")
hbox.pack_start(self.image,True,True,self.border)
self.content_box.pack_start(hbox,True,True,self.border)
self.buttons_box=Gtk.HBox()
self.buttons_box.set_valign(Gtk.Align.CENTER)
for x in range(0,4):
b=Gtk.Button(str(x))
b.set_size_request(100,100)
b.set_name("RELATED_BUTTON")
self.buttons_box.pack_start(b,False,False,5)
self.sw=Gtk.ScrolledWindow()
self.vp=Gtk.Viewport()
self.vp.set_halign(Gtk.Align.CENTER)
self.sw.add(self.vp)
self.sw.set_halign(Gtk.Align.CENTER)
self.sw.set_margin_bottom(30)
self.vp.add(self.buttons_box)
self.content_box.pack_end(self.sw,False,False,0)
self.revealer.add(self.content_box)
self.revealer.show_all()
self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK)
self.connect("button-press-event",self.area_clicked)
self.add(self.revealer)
def __init__(self):
"""
Initialise the class
"""
w = Gtk.Window(title="Chroma Driver Configuration")
w.set_wmclass('razer_bcd_utility', 'razer_bcd_utility')
w.set_position(Gtk.WindowPosition.CENTER)
w.set_size_request(1000, 600)
w.set_resizable(False)
try:
w.set_icon_from_file(
os.path.join(LOCATION_DATA, 'img/app-icon.svg'))
except:
w.set_icon_from_file(
'/usr/share/icons/hicolor/scalable/apps/polychromatic.svg')
w.connect("delete-event", Gtk.main_quit)
if not os.path.exists(LOCATION_DATA):
print('Data folder is missing. Exiting.')
sys.exit(1)
# Initialize Preferences
self.preferences = polychromatic.preferences.ChromaPreferences()
# Set up the daemon
try:
# Connect to the DBUS
self.daemon = razer.daemon_dbus.DaemonInterface()
# Initialize Profiles
self.profiles = polychromatic.profiles.ChromaProfiles(self.daemon)
# Load devices page normally.
#~ self.current_page = 'controller_devices' # TODO: Multi-device not yet supported.
self.current_page = 'menu'
self.multi_device_present = False
# "Globals"
self.kb_layout = razer.keyboard.get_keyboard_layout()
self.reactive_speed = 1
self.primary_rgb = razer.keyboard.RGB(0, 255, 0)
self.secondary_rgb = razer.keyboard.RGB(0, 0, 255)
self.current_effect = 'custom'
self.last_effect = 'unknown'
self.open_this_profile = None
# Set preferred colours
p_red = self.preferences.get_pref('primary_colors', 'red', 0)
p_green = self.preferences.get_pref('primary_colors', 'green', 255)
p_blue = self.preferences.get_pref('primary_colors', 'blue', 0)
s_red = self.preferences.get_pref('secondary_colors', 'red', 255)
s_green = self.preferences.get_pref('secondary_colors', 'green', 0)
s_blue = self.preferences.get_pref('secondary_colors', 'blue', 0)
self.primary_rgb_values = [p_red, p_green, p_blue]
self.primary_rgb = razer.keyboard.RGB(p_red, p_green, p_blue)
self.secondary_rgb_values = [s_red, s_green, s_blue]
self.secondary_rgb = razer.keyboard.RGB(s_red, s_green, s_blue)
except Exception as e:
# Load an error page instead.
print('There was a problem initializing the application or DBUS.')
self.current_page = 'error'
print('Exception: ', e)
# Create WebKit Container
self.webkit = WebKit2.WebView()
sw = Gtk.ScrolledWindow()
sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
sw.add(self.webkit)
# Build an auto expanding box and add our scrolled window
b = Gtk.VBox(homogeneous=False, spacing=0)
b.pack_start(sw, expand=True, fill=True, padding=0)
w.add(b)
# Post-actions after pages fully load.
self.webkit.connect('load-changed', self.load_changed_cb)
self.webkit.connect('notify::title', self.title_changed_cb)
self.webkit.connect('context-menu', self.context_menu_cb)
# Allows Keyboard SVGs to load.
self.webkit.get_settings().set_property(
'allow-file-access-from-file-urls', 1)
# Load the starting page
self.webkit.load_uri('file://' +
os.path.join(LOCATION_DATA, self.current_page +
'.html'))
# Show the window.
w.show_all()
Gtk.main()
# Create a full screen web browser showing the URL passed as first command line
# argument. The browser is very minimal: no menus or window chrome. A scrolling
# view is used.
#
# Requires Gtk 3 and WebKit2 4 and GObject Introspection, e.g.
import gi, signal, sys
gi.require_version('Gtk', '3.0')
gi.require_version('WebKit2', '4.0')
from gi.repository import GLib, Gtk, WebKit2
win = Gtk.Window()
win.connect('destroy', lambda w: Gtk.main_quit())
web = WebKit2.WebView()
settings = web.get_settings()
settings.set_allow_modal_dialogs(False)
settings.set_enable_plugins(False)
settings.set_enable_java(False)
settings.set_enable_write_console_messages_to_stdout(True)
settings.set_enable_webaudio(True)
settings.set_enable_webgl(True)
settings.set_enable_accelerated_2d_canvas(True)
#settings.set_allow_file_access_from_file_urls(True)
#settings.set_allow_universal_access_from_file_urls(True)
web.get_context().set_cache_model(WebKit2.CacheModel.DOCUMENT_VIEWER)
scroller = Gtk.ScrolledWindow()
def __init__(self, uid, title, url, width, height, resizable, fullscreen, min_size,
confirm_quit, background_color, debug, js_api, text_select, webview_ready):
BrowserView.instances[uid] = self
self.uid = uid
self.webview_ready = webview_ready
self.is_fullscreen = False
self.js_results = {}
self.load_event = Event()
self.load_event.clear()
glib.threads_init()
self.window = gtk.Window(title=title)
if resizable:
self.window.set_size_request(min_size[0], min_size[1])
self.window.resize(width, height)
else:
self.window.set_size_request(width, height)
self.window.set_resizable(resizable)
self.window.set_position(gtk.WindowPosition.CENTER)
# Set window background color
style_provider = gtk.CssProvider()
style_provider.load_from_data(
'GtkWindow {{ background-color: {}; }}'.format(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 confirm_quit:
self.window.connect('delete-event', self.on_destroy)
else:
self.window.connect('delete-event', self.close_window)
if js_api:
self.js_bridge = BrowserView.JSBridge(js_api, self.uid)
else:
self.js_bridge = None
self.text_select = 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)
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 url is not None:
self.webview.load_uri(url)
elif js_api is None:
self.load_event.set()
if fullscreen:
self.toggle_fullscreen()
import gi
import os
gi.require_version('WebKit2', '4.0')
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk, Gdk
from gi.repository import WebKit2 as WebKit
webview = WebKit.WebView()
path = 'loading.html'
path = os.path.realpath(path)
webview.load_uri("file://" + path)
scrolledWindow = Gtk.ScrolledWindow()
scrolledWindow.add(webview)
window = Gtk.Window()
window.set_decorated(False)
window.set_default_size(800, 450)
window.set_position(Gtk.WindowPosition.CENTER)
window.add(scrolledWindow)
window.show_all()
def quit(args):
Gtk.main_quit()
os.system("killall flask")
window.connect("destroy", quit)
Gtk.main()
def __init__(self, movie):
Gtk.Window.__init__(self, title="SmartTV OpenSource")
height = get_monitors()[0].height
aspect = height / 750
ratings = float(round(movie.getRating() / 2, 1))
self.movie = movie
self.divider = Gtk.Box(spacing=18)
self.image = getCardImg(
movie.getCovers()[2],
"./cache/cover-large={}".format(movie.getTitle()) + ".png",
width=500 * aspect,
heigth=height)
self.divider.set_hexpand(True)
self.divider.set_vexpand(True)
self.divider.set_margin_right(18)
self.divider.pack_start(self.image, False, False, 0)
self.title = Gtk.Label()
self.title.set_markup(
"<big><big><big><big>{}</big></big></big></big>".format(
movie.getTitleEn()))
self.title.set_hexpand(True)
self.title.set_halign(Gtk.Align.START)
self.desc = Gtk.Label()
self.desc.set_markup("<big><big>{}</big></big>".format(
movie.getDescription()))
self.desc.set_line_wrap(True)
self.basic_info = Gtk.Label(label="{}min / {}y / {}".format(
self.movie.getRuntime(), self.movie.getYear(),
self.movie.getLanguage()),
opacity=0.7)
self.basic_info.set_halign(Gtk.Align.START)
self.genres = Gtk.Label(opacity=0.7)
self.genres.set_markup("<big>{}</big>".format(" ".join(
self.movie.getGenres())))
self.genres.set_halign(Gtk.Align.START)
self.webview = WebKit2.WebView()
self.webview.load_html(
'<style>iframe{{width:100%;height:100%}}body,html{{margin:0}}</style><iframe src="https://www.youtube.com/embed/{}" frameborder="0"></iframe>'
.format(self.movie.getTrailerCode()))
# self.webview.set_vexpand(True)
print("ID:" + str(movie.getId()))
self.trailer_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.grid = Gtk.Grid()
self.grid.set_row_homogeneous(False)
self.grid.set_row_spacing(12)
self.grid.attach(self.title, 0, 0, 2, 1)
ratings_widget = getStarRating(ratings)
ratings_widget.set_halign(Gtk.Align.END)
ratings_widget.set_valign(Gtk.Align.CENTER)
self.grid.attach(ratings_widget, 2, 0, 1, 1)
self.grid.attach(self.genres, 0, 1, 3, 1)
self.grid.attach(self.basic_info, 0, 2, 3, 1)
self.grid.attach(self.desc, 0, 3, 3, 1)
self.grid.attach(self.webview, 0, 4, 3, 3)
self.divider.pack_end(self.grid, True, True, 0)
self.add(self.divider)
def toggle_preview(self, state):
if state.get_boolean():
# Insert a tag with ID to scroll to
# self.TextBuffer.insert_at_cursor('<span id="scroll_mark"></span>')
# TODO
# Find a way to find the next header, scroll to the next header.
# TODO: provide a local version of mathjax
# We need to convert relative routes to absolute ones
# For that first we need to know if the file is saved:
if self.filename:
base_path = os.path.dirname(self.filename)
else:
base_path = ''
os.environ['PANDOC_PREFIX'] = base_path + '/'
# Set the styles according the color theme
if self.settings.get_value("dark-mode"):
stylesheet = helpers.get_media_path('uberwriter_dark.css')
else:
stylesheet = helpers.get_media_path('uberwriter.css')
args = [
'pandoc', '-s', '--from=markdown', '--to=html5', '--mathjax',
'--css=' + stylesheet, '--lua-filter=' +
helpers.get_script_path('relative_to_absolute.lua'),
'--lua-filter=' + helpers.get_script_path('task-list.lua')
]
p = subprocess.Popen(args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
text = bytes(self.get_text(), "utf-8")
output = p.communicate(text)[0]
# Load in Webview and scroll to #ID
self.webview = WebKit.WebView()
self.webview_settings = self.webview.get_settings()
self.webview_settings.set_allow_universal_access_from_file_urls(
True)
self.webview.load_html(output.decode("utf-8"), 'file://localhost/')
# Delete the cursor-scroll mark again
# cursor_iter = self.TextBuffer.get_iter_at_mark(self.TextBuffer.get_insert())
# begin_del = cursor_iter.copy()
# begin_del.backward_chars(30)
# self.TextBuffer.delete(begin_del, cursor_iter)
self.ScrolledWindow.remove(self.TextEditor)
self.ScrolledWindow.add(self.webview)
self.webview.show()
# This saying that all links will be opened in default browser, \
# but local files are opened in appropriate apps:
self.webview.connect("decide-policy", self.on_click_link)
else:
self.ScrolledWindow.remove(self.webview)
self.webview.destroy()
self.ScrolledWindow.add(self.TextEditor)
self.TextEditor.show()
self.queue_draw()
return True
def addtab(self,
widget=None,
dummy=None,
dummier=None,
dummiest=None,
openurl="http://google.com/"):
self.web_view.append(WebKit2.WebView())
self.websettings.append(WebKit2.Settings())
# to set user agent, uncomment
self.websettings[len(self.websettings) - 1].set_property(
'user-agent', 'iPad') # won't set at all
# to enable, disable javascript
self.websettings[len(self.websettings) - 1].set_property(
'enable_javascript', False)
# to enable, disable webgl
self.websettings[len(self.websettings) - 1].set_property(
"enable-webgl", True)
self.web_view[len(self.web_view) - 1].set_settings(
self.websettings[len(self.websettings) - 1])
self.web_view[len(self.web_view) - 1].load_uri(openurl)
self.back_button.append(gtk.ToolButton(gtk.STOCK_GO_BACK))
self.back_button[len(self.back_button) - 1].connect(
"clicked", self.go_back)
self.forward_button.append(gtk.ToolButton(gtk.STOCK_GO_FORWARD))
self.forward_button[len(self.forward_button) - 1].connect(
"clicked", self.go_forward)
self.refresh_button.append(gtk.ToolButton(gtk.STOCK_REFRESH))
self.refresh_button[len(self.refresh_button) - 1].connect(
"clicked", self.refresh)
self.url_bar.append(gtk.Entry())
self.url_bar[len(self.url_bar) - 1].connect("activate", self.on_active)
# enable (green), disable (red) javascript
self.jsbutton.append(gtk.Button('js'))
self.jsbutton[len(self.jsbutton) - 1].connect("activate",
self.toggle_js)
self.jsbutton[len(self.jsbutton) - 1].connect("clicked",
self.toggle_js)
self.jsbutton[len(self.jsbutton) - 1].modify_bg(
gtk.StateType.NORMAL, Gdk.color_parse("red"))
self.etcbutton.append(gtk.Button('Prefs'))
self.historybutton.append(gtk.Button('Hist'))
self.historybutton[len(self.historybutton) - 1].connect(
"activate", self.historytab)
self.historybutton[len(self.historybutton) - 1].connect(
"clicked", self.historytab)
self.etcbutton[len(self.etcbutton) - 1].connect(
"activate", self.show_prefs)
self.etcbutton[len(self.etcbutton) - 1].connect(
"clicked", self.show_prefs)
self.newtab.append(gtk.Button('+'))
self.newtab[len(self.newtab) - 1].connect("activate", self.addtab)
self.newtab[len(self.newtab) - 1].connect("clicked", self.addtab)
self.closetab.append(gtk.Button('X'))
self.closetab[len(self.closetab) - 1].connect("activate",
self.removetab)
self.closetab[len(self.closetab) - 1].connect("clicked",
self.removetab)
self.web_view[len(self.web_view) - 1].connect("load_changed",
self.on_load_changed)
#self.web_view[len(self.web_view)-1].connect("download_requested", self.download)
self.scroll_window.append(gtk.ScrolledWindow(None, None))
self.scroll_window[len(self.scroll_window) - 1].add(
self.web_view[len(self.web_view) - 1])
self.scroll_window[len(self.scroll_window) - 1].set_policy(
gtk.PolicyType.AUTOMATIC, gtk.PolicyType.AUTOMATIC)
self.hbox.append(gtk.HBox(False, 0))
self.vbox.append(gtk.VBox(False, 0))
self.mainbox = gtk.VBox(False, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.back_button[len(self.back_button) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.forward_button[len(self.forward_button) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.refresh_button[len(self.refresh_button) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.newtab[len(self.newtab) - 1], False, True, 3)
self.hbox[len(self.hbox) - 1].pack_start(
self.closetab[len(self.closetab) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.url_bar[len(self.url_bar) - 1], True, True, 3)
self.hbox[len(self.hbox) - 1].pack_start(
self.jsbutton[len(self.jsbutton) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.historybutton[len(self.historybutton) - 1], False, True, 0)
self.hbox[len(self.hbox) - 1].pack_start(
self.etcbutton[len(self.etcbutton) - 1], False, True, 0)
self.vbox[len(self.vbox) - 1].pack_start(self.hbox[len(self.hbox) - 1],
False, True, 0)
self.vbox[len(self.vbox) - 1].pack_start(
self.scroll_window[len(self.scroll_window) - 1], True, True, 0)
self.tabbook.append_page(self.vbox[len(self.vbox) - 1])
self.tabbook.show_all()
self.tabbook.set_current_page(len(self.vbox) - 1 + self.n)
class Prisma(Gtk.Window):
title = 'Fegeya Prisma'
default_url = 'http://duckduckgo.com'
default_protocol = 'http'
window = Gtk.Window(title=title)
webview = WebKit2.WebView()
cookie_context = ''
cookie_manager = ''
header_bar = Gtk.HeaderBar()
scrolled_window = Gtk.ScrolledWindow()
url_bar = Gtk.Entry()
home_button = Gtk.ToolButton()
back_button = Gtk.ToolButton()
forward_button = Gtk.ToolButton()
reload_button = Gtk.ToolButton()
security = Gtk.Label()
img = Gtk.Image()
def __init__(self):
from pathlib import Path
self.window.connect('destroy', Gtk.main_quit)
self.header_bar.set_title(self.title)
self.header_bar.set_subtitle("Browsing for everyone, everytime.")
self.header_bar.set_show_close_button(True)
self.window.set_size_request(900, 600)
self.cookie_context = WebKit2.WebContext()
self.cookie_manager = WebKit2.WebContext.get_cookie_manager(
self.cookie_context)
self.cookie_manager.set_accept_policy(
WebKit2.CookieAcceptPolicy.ALWAYS)
self.cookie_manager.set_persistent_storage(
'{home_dir}/.config/prisma/prismacook.ies'.format(
home_dir=Path.home()), WebKit2.CookiePersistentStorage.TEXT)
self.webview = WebKit2.WebView.new_with_context(self.cookie_context)
if path.exists('/usr/share/pixmaps/prism/homepage/index.html'):
self.default_url = 'file:///usr/share/pixmaps/prism/homepage/index.html'
if 'file:///' in self.default_url:
self.security.set_label('🏠 | Home')
elif 'https' in self.default_url:
self.security.set_label('🔒 | Home')
else:
self.security.set_label('🔓 | Home')
self.initialize_widgets()
self.connect_signals()
self.window.set_titlebar(self.header_bar)
self.window.show_all()
def initialize_widgets(self):
img = Gtk.Image()
if path.exists('/usr/share/pixmaps/prism/prism_32.png'):
img.set_from_file('/usr/share/pixmaps/prism/prism_32.png')
self.home_button.set_icon_widget(img)
self.img = Gtk.Image()
if path.exists('/usr/share/pixmaps/prism/white_arrow_left.png'):
self.img.set_from_file(
'/usr/share/pixmaps/prism/white_arrow_left.png')
self.back_button.set_icon_widget(self.img)
self.img = Gtk.Image()
if path.exists('/usr/share/pixmaps/prism/white_arrow_right.png'):
self.img.set_from_file(
'/usr/share/pixmaps/prism/white_arrow_right.png')
else:
self.img.set_from_icon_name('go-next', Gtk.IconSize.SMALL_TOOLBAR)
self.forward_button.set_icon_widget(self.img)
self.img = Gtk.Image()
if path.exists('/usr/share/pixmaps/prism/white_refresh.png'):
self.img.set_from_file(
'/usr/share/pixmaps/prism/white_refresh.png')
else:
self.img.set_from_icon_name('view-refresh',
Gtk.IconSize.SMALL_TOOLBAR)
self.reload_button.set_icon_widget(self.img)
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.webview.load_uri(self.default_url)
self.back_button.connect('clicked', self.go_back)
self.forward_button.connect('clicked', self.go_forward)
self.reload_button.connect('clicked', self.reload)
self.url_bar.set_icon_from_icon_name(Gtk.EntryIconPosition.PRIMARY,
'system-search-symbolic')
box.add(self.home_button)
box.add(self.url_bar)
box.add(self.back_button)
box.add(self.forward_button)
box.add(self.reload_button)
box.add(self.security)
self.header_bar.pack_start(box)
self.scrolled_window.add(self.webview)
self.window.add(self.scrolled_window)
def connect_signals(self):
self.webview.connect('load_changed', self.on_load_changed)
self.url_bar.connect('activate', self.on_activate)
def on_load_changed(self, data, web):
self.url_bar.set_text(self.webview.get_uri())
self.on_check_security()
def on_check_security(self):
if 'file:///' in self.webview.get_uri():
self.security.set_label('🏠 | Home')
if self.webview.get_uri() == self.default_url:
self.url_bar.set_text('prisma:home')
elif 'https' in self.webview.get_uri():
self.security.set_label('🔒 | Secure')
else:
self.security.set_label('🔓 | Unsecure')
def on_activate(self, data):
url = self.url_bar.get_text()
if url == 'prisma:home':
self.webview.load_uri(self.default_url)
return
self.on_check_security()
if 'http' in url and not 'https' in url:
if 'google' in self.default_url:
url = self.default_url + '/search?q=' + self.url_bar.get_text()
elif 'duckduckgo' in self.default_url:
url = self.default_url + '?q=' + self.url_bar.get_text()
else:
url = self.default_url + '/' + self.url_bar.get_text()
else:
url = self.default_protocol + self.url_bar.get_text()
self.webview.load_uri(url)
def go_back(self, data):
self.webview.go_back()
def go_forward(self, data):
self.webview.go_forward()
def reload(self, data):
self.webview.reload()
def on_inspect_web_view(self, inspector, wk_view, *data):
myview = WebKit2.WebView()
self.window.add(myview)
return myview
def __init__(self):
Gtk.Window.__init__(self, title="AlWeb")
self.set_default_size(1920, 1080)
header_bar = Gtk.HeaderBar()
header_bar.set_show_close_button(True)
header_bar.props.title = ">>>>> || <<<<<"
self.set_titlebar(header_bar)
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.add(self.box)
self.notebook = Gtk.Notebook()
self.box.pack_start(self.notebook, True, True, 0)
#first tab/ home page
tab = Gtk.Box()
#web view
main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
view_box = Gtk.Box()
self.webview = WebKit2.WebView()
self.webview.show()
view_box.pack_start(self.webview, True, True, 0)
#url bar
address_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=2)
#go backward
self.backward_button = Gtk.Button()
self.backward_button.add(
Gtk.Arrow(Gtk.ArrowType.LEFT, Gtk.ShadowType.NONE))
self.backward_button.connect("clicked",
lambda x: self.webview.go_back())
#go forward
self.forward_button = Gtk.Button()
self.forward_button.add(
Gtk.Arrow(Gtk.ArrowType.RIGHT, Gtk.ShadowType.NONE))
self.forward_button.connect("clicked",
lambda x: self.webview.go_forward())
#reload/load
self.go_button = Gtk.Button(label="Go")
self.go_button.connect("clicked", self._load_url)
#url entry
self.url_bar = Gtk.Entry()
self.url_bar.set_text("Enter URL")
self.url_bar.connect("activate", self._load_url)
#adding items to address box
address_box.add(self.backward_button)
address_box.add(self.forward_button)
address_box.add(self.go_button)
address_box.pack_start(self.url_bar, True, True, 0)
#adding boxes
main_box.add(address_box)
main_box.pack_start(view_box, True, True, 0)
tab.pack_start(main_box, True, True, 0)
self.notebook.append_page(tab, Gtk.Label('Home'))
print(self.notebook.get_n_pages())
self.button = Gtk.Button(label='new tab')
self.button.connect('clicked', self.on_button_clicked)
header_bar.pack_end(self.button)
def create_components(self):
self.left_box = Gtk.VBox()
self.left_box.set_hexpand(True)
self.button_box = Gtk.HBox()
self.right_box = Gtk.VBox()
self.line1 = Gtk.HBox()
self.line1.set_homogeneous(True)
self.line2 = Gtk.HBox()
self.line2.set_homogeneous(True)
self.heading = Gtk.Label()
self.heading.set_markup('<span size="xx-large"></span>')
self.heading.set_hexpand(True)
self.heading.set_vexpand(False)
self.heading.set_halign(Gtk.Align.START)
self.heading.set_valign(Gtk.Align.START)
self.short_description = Gtk.Label('')
self.short_description.set_hexpand(True)
self.short_description.set_vexpand(False)
self.short_description.set_halign(Gtk.Align.START)
self.short_description.set_valign(Gtk.Align.START)
self.version = Gtk.Label('Version: ')
self.version.set_hexpand(True)
self.version.set_vexpand(False)
self.version.set_halign(Gtk.Align.START)
self.version.set_valign(Gtk.Align.START)
self.last_updated_date = Gtk.Label('Last Updated: ')
self.last_updated_date.set_hexpand(True)
self.last_updated_date.set_vexpand(False)
self.last_updated_date.set_halign(Gtk.Align.START)
self.last_updated_date.set_valign(Gtk.Align.START)
self.developer = Gtk.Label('Developer: ')
self.developer.set_hexpand(True)
self.developer.set_vexpand(False)
self.developer.set_halign(Gtk.Align.START)
self.developer.set_valign(Gtk.Align.START)
self.license = Gtk.Label('License: ')
self.license.set_hexpand(True)
self.license.set_vexpand(False)
self.license.set_halign(Gtk.Align.START)
self.license.set_valign(Gtk.Align.START)
self.install = Gtk.Button('Install')
self.install.set_hexpand(False)
self.uninstall = Gtk.Button('Uninstall')
self.uninstall.set_hexpand(False)
self.update = Gtk.Button('Update')
self.update.set_hexpand(False)
self.image = Gtk.Image.new_from_file('')
self.image.set_hexpand(True)
self.image.set_halign(Gtk.Align.START)
self.image.set_valign(Gtk.Align.START)
self.details = WebKit2.WebView()
self.details.load_html('')
self.details.set_vexpand(True)
settings = WebKit2.Settings()
settings.set_default_font_family('Open Sans')
settings.set_default_font_size(14)
self.details.set_settings(settings)
self.package_info_label = Gtk.Label()
self.package_info_label.set_markup('<span size="xx-large">Screenshot</span>')
self.package_info_label.set_hexpand(True)
self.package_info_label.set_vexpand(False)
self.package_info_label.set_halign(Gtk.Align.END)
self.package_info_label.set_valign(Gtk.Align.START)
self.install.connect('clicked', misc.install_app, self.context)
self.uninstall.connect('clicked', misc.remove_app, self.context)
self.update.connect('clicked', misc.update_app, self.context)
