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)