def global_webkit_init(): """ this sets the defaults for webkit, its important that this gets run if you want a secure webkit session """ session = WebKit.get_default_session() # add security by default (see bugzilla #666280 and #666276) # enable certificates validation in webkit views unless specified otherwise if not "SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK" in os.environ: session = webkit.get_default_session() session.set_property("ssl-ca-file", "/etc/ssl/certs/ca-certificates.crt") else: # WARN the user!! Do not remove this LOG.warning("SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK " + "has been specified, all purchase transactions " + "are now INSECURE and UNENCRYPTED!!") # cookies by default fname = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "cookies.txt") # clear cookies again in a new session, see #1018347 comment #4 # there is no "logout" support right now on any of the USC pages try: os.remove(fname) except OSError: pass cookie_jar = Soup.CookieJarText.new(fname, False) session.add_feature(cookie_jar) # optional session debugging if "SOFTWARE_CENTER_DEBUG_WEBKIT" in os.environ: # alternatively you can use HEADERS, BODY here logger = Soup.Logger.new(Soup.LoggerLogLevel.BODY, -1) logger.attach(session)
def global_webkit_init(): """ this sets the defaults for webkit, its important that this gets run if you want a secure webkit session """ session = WebKit.get_default_session() # add security by default (see bugzilla #666280 and #666276) # enable certificates validation in webkit views unless specified otherwise if not "SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK" in os.environ: session = webkit.get_default_session() session.set_property( "ssl-ca-file", "/etc/ssl/certs/ca-certificates.crt") else: # WARN the user!! Do not remove this LOG.warning("SOFTWARE_CENTER_FORCE_DISABLE_CERTS_CHECK " + "has been specified, all purchase transactions " + "are now INSECURE and UNENCRYPTED!!") # cookies by default fname = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "cookies.txt") # clear cookies again in a new session, see #1018347 comment #4 # there is no "logout" support right now on any of the USC pages try: os.remove(fname) except OSError: pass cookie_jar = Soup.CookieJarText.new(fname, False) session.add_feature(cookie_jar) # optional session debugging if "SOFTWARE_CENTER_DEBUG_WEBKIT" in os.environ: # alternatively you can use HEADERS, BODY here logger = Soup.Logger.new(Soup.LoggerLogLevel.BODY, -1) logger.attach(session)
def __init__(self, cookie_path="~/.netflix.cookie", *args, **kwargs): Gtk.Window.__init__(self, title=sys.argv[1]) icontheme = Gtk.IconTheme.get_default() self.set_icon_from_file(sys.argv[3]) super(NetflixWindow, self).__init__(*args, **kwargs) cookiejar = Soup.CookieJarText.new( os.path.expanduser(cookie_path), False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar) self.width = int(sys.argv[4]) self.height = int(sys.argv[5]) self.set_default_size(self.width, self.height) self.connect('destroy', Gtk.main_quit) self.connect('delete-event', Gtk.main_quit) self.scroll = Gtk.ScrolledWindow() self.web = WebKit.WebView() self.add(self.scroll) self.scroll.add(self.web) self.show_all() self.web.open(sys.argv[2])
def __init__(self): GObject.GObject.__init__(self) self.window = window = Gtk.Window() self.inspectorWindow = Gtk.Window() self.session = WebKit.get_default_session() self.zcbrowser = MBCZeroconfBrowser() self.services = {} self.zcbrowser.connect('service-up', self.on_new_service) self.zcbrowser.connect('service-down', self.on_service_removed) self.webView = webView = WebKit.WebView() window.add(webView) window.set_decorated(False) window.set_title('MBC - Vineyard') self.init_settings() self.add_inspector() self.add_cookie_jar() webView.connect ("navigation-policy-decision-requested", self.decide_policy_cb) webView.connect ("close-web-view", lambda app: Gtk.main_quit()) webView.connect ("load-error", self.load_error_cb) webView.connect ("document-load-finished", self.load_finished_cb) webView.connect ("window-object-cleared", self.window_object_cleared_cb) webView.set_property ("view-mode", WebKit.WebViewViewMode.FULLSCREEN) window.connect ("destroy", lambda app: Gtk.main_quit()) window.show_all () window.fullscreen () webView.grab_focus() # replace this with magic. webView.load_uri('http://localhost:3000/')
def setup_webkit_session(self): session = WebKit.get_default_session() cache = get_or_create_directory(op.join( GLib.get_user_cache_dir(), 'fogger', self.app.uuid)) cookie_jar = Soup.CookieJarText.new(op.join(cache, 'WebkitSession'), False) session.add_feature(cookie_jar) session.props.max_conns_per_host = 8
def __init__(self): super(VKWebkitAuth, self).__init__(_("vk.com authorization"), None, Gtk.DialogFlags.MODAL, ()) self.set_size_request(550, -1) self.auth_url = "http://oauth.vk.com/oauth/authorize?" + \ "redirect_uri=http://oauth.vk.com/blank.html&response_type=token&" + \ "client_id=%s&scope=%s" % (self.CLIENT_ID, ",".join(self.SCOPE)) self.web_view = WebKit.WebView() self.web_view.show() self.vbox.pack_start(self.web_view, False, False, 0) self.web_view.connect('onload-event', self.on_load) session = WebKit.get_default_session() if FC().proxy_enable and FC().proxy_url: if FC().proxy_user and FC().proxy_password: proxy_url = "http://%s:%s@%s" % ( FC().proxy_user, FC().proxy_password, FC().proxy_url) else: proxy_url = "http://%s" % FC().proxy_url soup_url = Soup.URI.new(proxy_url) session.set_property("proxy-uri", soup_url) else: session.set_property("proxy-uri", None) cookiejar = Soup.CookieJarText.new(cookiefile, False) session.add_feature(cookiejar) self.access_token = None self.user_id = None self.first_page_loaded = False
def webkit_set_proxy_uri(scheme = None, host = None, port = None, user = None, passwd = None): try: session = WebKit.get_default_session() if looseVersion(Soup._version) < looseVersion('2.4'): session.set_property("max-conns", 3) session.set_property("max-conns-per-host", 1) else: session.set_property("max-conns", 10) session.set_property("max-conns-per-host", 5) session.set_property("timeout", 10) if scheme == None: return True elif ":" in scheme: proxy_uri = Soup.URI.new(str(scheme)) elif host: proxy_uri = Soup.URI.new("http://127.0.0.1") proxy_uri.set_scheme(str(scheme)) proxy_uri.set_host(str(host)) if port: proxy_uri.set_port(int(port)) if user: proxy_uri.set_user(str(user)) if passwd: proxy_uri.set_password(str(passwd)) session.set_property("proxy-uri", proxy_uri) return True except: exctype, value = sys.exc_info()[:2] print 'error: webkit_set_proxy_uri: (%s, %s)' % (exctype,value) return False
def __init__(self, *args, **kwargs): super(Messenger, self).__init__(*args, **kwargs) self.connect("destroy", Gtk.main_quit) self.connect("key-press-event", self.key_pressed) self.set_size_request(800, 600) self.set_icon_from_file("/opt/messenger/messenger.svg") if not os.path.exists(os.path.expanduser("~/.messenger")) or not os.path.isdir(os.path.expanduser("~/.messenger")): os.makedirs(os.path.expanduser("~/.messenger")) open(os.path.expanduser("~/.messenger/cookies.txt"), "a").close() cookiejar = Soup.CookieJarText.new(os.path.expanduser("~/.messenger/cookies.txt"), False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar) self.webview = WebKit.WebView() self.webview.get_settings().set_property("enable-smooth-scrolling", True) self.webview.get_settings().set_property("enable-default-context-menu", False) self.webview.connect("title-changed", self.title_changed) self.webview.connect("load-finished", self.load_finished) self.webview.connect("new-window-policy-decision-requested", self.link_clicked) self.scrolled_window = Gtk.ScrolledWindow() self.webview.load_uri("https://messenger.com/login") self.scrolled_window.add(self.webview) self.add(self.scrolled_window) self.show_all()
def __init__(self, activity, window_xid): self.parent_window_xid = window_xid url, title = get_help_url_and_title(activity) has_local_help = url is not None self._mode = _MODE_HELP if has_local_help else _MODE_SOCIAL_HELP Gtk.Window.__init__(self) box = Gtk.Box() box.set_orientation(Gtk.Orientation.VERTICAL) self.add(box) box.show() self.set_decorated(False) self.set_position(Gtk.WindowPosition.CENTER_ALWAYS) self.set_border_width(style.LINE_WIDTH) self.set_has_resize_grip(False) width = Gdk.Screen.width() - style.GRID_CELL_SIZE * 2 height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 2 self.set_size_request(width, height) self.connect('realize', self.__realize_cb) self.connect('hide', self.__hide_cb) self.connect('key-press-event', self.__key_press_event_cb) toolbar = Toolbar(title, has_local_help) box.pack_start(toolbar, False, False, 0) toolbar.show() toolbar.connect('stop-clicked', self.__stop_clicked_cb) toolbar.connect('mode-changed', self.__mode_changed_cb) session = WebKit.get_default_session() cookie_jar = SoupGNOME.CookieJarSqlite( filename=os.path.join(env.get_profile_path(), 'social-help.cookies'), read_only=False) session.add_feature(cookie_jar) self._webview = WebKit.WebView() self._webview.set_full_content_zoom(True) self._webview.connect('resource-request-starting', self._resource_request_starting_cb) scrolled_window = Gtk.ScrolledWindow() scrolled_window.add(self._webview) scrolled_window.show() box.pack_start(scrolled_window, True, True, 0) self._webview.show() language = self._get_current_language() if has_local_help: self._help_url = 'file://' + self._get_help_file(language, url) self._social_help_url = '{}/goto/{}'.format( get_social_help_server(), activity.get_bundle_id()) self._webview.connect( 'notify::load-status', self.__load_status_changed_cb) self._load_mode(self._mode)
def __init__(self): Gtk.Dialog.__init__(self, _("vk.com authorization"), None, Gtk.DialogFlags.MODAL, ()) ChildTopWindow.__init__(self) self.set_size_request(550, -1) self.auth_url = "http://oauth.vk.com/oauth/authorize?" + \ "redirect_uri=http://oauth.vk.com/blank.html&response_type=token&" + \ "client_id=%s&scope=%s" % (self.CLIENT_ID, ",".join(self.SCOPE)) self.web_view = WebKit.WebView() self.vbox.pack_start(self.web_view, False, False, 0) self.web_view.connect('resource-load-finished', self.on_load) session = WebKit.get_default_session() if FC().proxy_enable and FC().proxy_url: if FC().proxy_user and FC().proxy_password: proxy_url = "http://%s:%s@%s" % (FC().proxy_user, FC().proxy_password, FC().proxy_url) else: proxy_url = "http://%s" % FC().proxy_url soup_url = Soup.URI.new(proxy_url) session.set_property("proxy-uri", soup_url) else: session.set_property("proxy-uri", None) cookiejar = Soup.CookieJarText.new(cookiefile, False) session.add_feature(cookiejar) self.access_token = None self.user_id = None self.on_load_method_finished = False
def config_soup(self): """Load config values to a soup session""" soup_session = WebKit.get_default_session() cid = soup_session.connect("request_queued", self.on_soup_request_queued) soup_session.request_queued_cid = cid sec = SOUP_SECTION for k in SOUP_PROPERTY_TYPE [int]: if k in ["cache-size"]: continue val = self.config.getint(sec, k) soup_session.set_property(k, val) for k in SOUP_PROPERTY_TYPE [bool]: val = self.config.getboolean(sec, k) if k == "enable-disk-cache": if val: self.load_soup_cache(soup_session) else: self.unload_soup_cache(soup_session) elif k == "enable-persistent-cookie": if val: self.load_soup_cookiejar(soup_session) else: self.unload_soup_cookiejar(soup_session) elif k in ["enable-do-not-track"]: pass else: soup_session.set_property(k, val)
def test_have_cookie_jar(self): # ensure we have a cookie jar available session = WebKit.get_default_session() cookie_jars = [feature for feature in session.get_features(Soup.SessionFeature) if isinstance(feature, Soup.CookieJar)] self.assertEqual(len(cookie_jars), 1)
def webkit_set_proxy_uri(scheme = None, host = None, port = None, user = None, passwd = None): try: session = WebKit.get_default_session() if looseVersion(Soup._version) < looseVersion('2.4'): session.set_property("max-conns", 3) session.set_property("max-conns-per-host", 1) else: session.set_property("max-conns", 10) session.set_property("max-conns-per-host", 5) if scheme == None: return True elif ":" in scheme: proxy_uri = Soup.URI.new(str(scheme)) elif host: proxy_uri = Soup.URI.new("http://127.0.0.1") proxy_uri.set_scheme(str(scheme)) proxy_uri.set_host(str(host)) if port: proxy_uri.set_port(int(port)) if user: proxy_uri.set_user(str(user)) if passwd: proxy_uri.set_password(str(passwd)) session.set_property("proxy-uri", proxy_uri) return True except: exctype, value = sys.exc_info()[:2] print 'error: webkit_set_proxy_uri: (%s, %s)' % (exctype,value) return False
def __init__(self, activity, window_xid): self.parent_window_xid = window_xid url, title = get_help_url_and_title(activity) has_local_help = url is not None self._mode = _MODE_HELP if has_local_help else _MODE_SOCIAL_HELP Gtk.Window.__init__(self) box = Gtk.Box() box.set_orientation(Gtk.Orientation.VERTICAL) self.add(box) box.show() self.set_decorated(False) self.set_position(Gtk.WindowPosition.CENTER_ALWAYS) self.set_border_width(style.LINE_WIDTH) self.set_has_resize_grip(False) width = Gdk.Screen.width() - style.GRID_CELL_SIZE * 2 height = Gdk.Screen.height() - style.GRID_CELL_SIZE * 2 self.set_size_request(width, height) self.connect('realize', self.__realize_cb) self.connect('hide', self.__hide_cb) self.connect('key-press-event', self.__key_press_event_cb) toolbar = Toolbar(title, has_local_help) box.pack_start(toolbar, False, False, 0) toolbar.show() toolbar.connect('stop-clicked', self.__stop_clicked_cb) toolbar.connect('mode-changed', self.__mode_changed_cb) session = WebKit.get_default_session() cookie_jar = SoupGNOME.CookieJarSqlite(filename=os.path.join( env.get_profile_path(), 'social-help.cookies'), read_only=False) session.add_feature(cookie_jar) self._webview = WebKit.WebView() self._webview.set_full_content_zoom(True) self._webview.connect('resource-request-starting', self._resource_request_starting_cb) scrolled_window = Gtk.ScrolledWindow() scrolled_window.add(self._webview) scrolled_window.show() box.pack_start(scrolled_window, True, True, 0) self._webview.show() language = self._get_current_language() if has_local_help: self._help_url = 'file://' + self._get_help_file(language, url) self._social_help_url = '{}/goto/{}'.format(get_social_help_server(), activity.get_bundle_id()) self._webview.connect('notify::load-status', self.__load_status_changed_cb) self._load_mode(self._mode)
def test_have_cookie_jar(self): # ensure we have a cookie jar available session = WebKit.get_default_session() cookie_jars = [ feature for feature in session.get_features(Soup.SessionFeature) if isinstance(feature, Soup.CookieJar) ] self.assertEqual(len(cookie_jars), 1)
def loadSession(self): if not os.path.exists(self.pidir): os.mkdir(self.pidir) if not os.path.exists(self.sessiondir): os.mkdir(self.sessiondir) session = WebKit.get_default_session() cookiepath = self.sessiondir + "/" + "cookies" cookiejar = Soup.CookieJarText(filename=cookiepath, read_only=False) session.add_feature(cookiejar)
def global_webkit_init(): session = WebKit.get_default_session() fname = os.path.join(SOFTWARE_CENTER_CACHE_DIR, "cookies.txt") # clear cookies again in a new session, see #1018347 comment #4 # there is no "logout" support right now on any of the USC pages try: os.remove(fname) except OSError: pass cookie_jar = Soup.CookieJarText.new(fname, False) session.add_feature(cookie_jar)
def __init__(self): # Create GTK window self.window = Gtk.Window() self.window.set_title('Slacker') self.window.connect('destroy', Gtk.main_quit) # Quit cleanly self.window.set_default_size(1200,720) # Create persistent cookie storage cookiejar = Soup.CookieJarText.new(self.cookie_path, False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar)
def setup_features(self): try: session = WebKit.get_default_session() cookie = Soup.CookieJarText(filename=os.path.join(CONFIG_ROOT, 'cookies')) session.add_feature(cookie) self._cache = Soup.Cache(cache_dir=os.path.join(CONFIG_ROOT, 'cache'), cache_type=Soup.CacheType.SHARED) session.add_feature(self._cache) self._cache.set_max_size(10 * 1024 * 1024) self._cache.load() except Exception, e: log.error("setup_features failed with %s" % e)
def __init__(self, *args, **kwargs): # TODO: Change to DOCUMENT_VIEWER after we start caching remote # resources at item processing stage WebKit.set_cache_model(WebKit.CacheModel.DOCUMENT_BROWSER) WebKit.get_default_session().set_property('max-conns-per-host', 8) settings = WebKit.WebSettings() settings.set_properties( **{ # These three saves us ~25MiB of residental memory 'enable_scripts': False, 'enable_plugins': False, 'enable_java_applet': False, # We already have most files cached and load locally 'enable_page_cache': False, 'enable_dns_prefetching': False, 'enable_private_browsing': True, # We don't use any of these features 'enable_html5_database': False, 'enable_html5_local_storage': False, 'enable_offline_web_application_cache': False, 'enable_xss_auditor': False, 'resizable_text_areas': False, # Need this one of usability reasons. 'enable_default_context_menu': False, # Enable in case developer tools are needed 'enable_developer_extras': arguments.devtools }) super(ItemView, self).__init__(*args, settings=settings, **kwargs) self.connect('show', self.on_show) self.connect('style-updated', self.on_style) self.connect('notify::item-id', self.on_item_change) self.connect('console-message', self.on_console_message) self.connect('context-menu', self.on_ctx_menu) # Load base template template_path = get_data_path('ui', 'feedview', 'template.html') self.load_uri('file://' + template_path)
def __init__(self, com_dict: object): """ Initialize the process. """ from gi.repository import Soup as libsoup from gi.repository import WebKit as libwebkit from gi.repository import Gtk as gtk from gi.repository import Gdk as gdk from gi.repository import GLib as glib self._icon_db = libwebkit.get_favicon_database() cookiejar = libsoup.CookieJar() cookiejar.set_accept_policy( libsoup.CookieJarAcceptPolicy.NO_THIRD_PARTY) session = libwebkit.get_default_session() print("SESSION: ", session) session.add_feature(cookiejar) session.set_property('ssl-use-system-ca-file', True) session.set_property('ssl-strict', True) print("SESSION PROP", session.get_property('tls-database')) # session.connect('connection-created', self._soup_connection) # proxy_uri = libsoup.URI.new(os.getenv('http_proxy')) # session.set_property('proxy-uri', proxy_uri) self._libsoup = libsoup self._gtk = gtk self._gdk = gdk self._glib = glib self._libwebkit = libwebkit self._dict = com_dict self._coms = [] self._pid = multiprocessing.current_process().pid self._windows = [] for socket_id, com_pipe in self._dict.items(): print("CREATING: ", socket_id, com_pipe) try: com_pipe.send(('pid', self._pid)) except BrokenPipeError as err: print("BROKEN PIPE: ", err, ' on PIPE ', com_pipe) continue self._windows.append(self._create_window(socket_id, com_pipe))
def setup_features(self): try: session = WebKit.get_default_session() session.connect('request-queued', self.on_session_request_queued) cookie = Soup.CookieJarText( filename=os.path.join(CONFIG_ROOT, 'cookies')) session.add_feature(cookie) self._cache = Soup.Cache(cache_dir=os.path.join( CONFIG_ROOT, 'cache'), cache_type=Soup.CacheType.SHARED) session.add_feature(self._cache) self._cache.set_max_size(10 * 1024 * 1024) self._cache.load() except Exception, e: log.error("setup_features failed with %s" % e)
def __init__(self, com_dict: object): """ Initialize the process. """ from gi.repository import Soup as libsoup from gi.repository import WebKit as libwebkit from gi.repository import Gtk as gtk from gi.repository import Gdk as gdk from gi.repository import GLib as glib self._icon_db = libwebkit.get_favicon_database() cookiejar = libsoup.CookieJar() cookiejar.set_accept_policy(libsoup.CookieJarAcceptPolicy.NO_THIRD_PARTY) session = libwebkit.get_default_session() print("SESSION: ", session) session.add_feature(cookiejar) session.set_property('ssl-use-system-ca-file', True) session.set_property('ssl-strict', True) print("SESSION PROP", session.get_property('tls-database')) # session.connect('connection-created', self._soup_connection) # proxy_uri = libsoup.URI.new(os.getenv('http_proxy')) # session.set_property('proxy-uri', proxy_uri) self._libsoup = libsoup self._gtk = gtk self._gdk = gdk self._glib = glib self._libwebkit = libwebkit self._dict = com_dict self._coms = [] self._pid = multiprocessing.current_process().pid self._windows = [] for socket_id, com_pipe in self._dict.items(): print("CREATING: ", socket_id, com_pipe) try: com_pipe.send(('pid', self._pid)) except BrokenPipeError as err: print("BROKEN PIPE: ", err, ' on PIPE ', com_pipe) continue self._windows.append(self._create_window(socket_id, com_pipe))
def __init__(self, conf): cid = conf['client_id'] curl = conf['client_url'] self._conf = conf self._client = stravalib.Client() self._web = WebKit.WebView() self._win = Gtk.Window() self._authurl = self._client.authorization_url(client_id=cid, redirect_uri=curl, scope='write') # Auth condition self._authcv = threading.Condition() # Cookie processing cpath = os.path.expanduser(self._conf['cookiepath']) cookiejar = Soup.CookieJarText.new(cpath, False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar) # Setup Webkit callbacks self._web.connect('load-committed', self.load_start) self._web.connect('load-error', self.load_error) # Setup Web Window self._win.set_title('Strava Authentication') self._win.set_default_size(800, 600) # Add browser sw = Gtk.ScrolledWindow() sw.add(self._web) self._win.add(sw) # Event handlers self._win.connect('delete-event', Gtk.main_quit) # Hack (for some reason, not opening something here causes # things to crash) self._win.show_all() self._web.open('http://strava.com') self._win.hide()
def __init__ ( self, conf ): cid = conf['client_id'] curl = conf['client_url'] self._conf = conf self._client = stravalib.Client() self._web = WebKit.WebView() self._win = Gtk.Window() self._authurl = self._client.authorization_url(client_id=cid, redirect_uri=curl, scope='write') # Auth condition self._authcv = threading.Condition() # Cookie processing cpath = os.path.expanduser(self._conf['cookiepath']) cookiejar = Soup.CookieJarText.new(cpath, False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar) # Setup Webkit callbacks self._web.connect('load-committed', self.load_start) self._web.connect('load-error', self.load_error) # Setup Web Window self._win.set_title('Strava Authentication') self._win.set_default_size(800, 600) # Add browser sw = Gtk.ScrolledWindow() sw.add(self._web) self._win.add(sw) # Event handlers self._win.connect('delete-event', Gtk.main_quit) # Hack (for some reason, not opening something here causes # things to crash) self._win.show_all() self._web.open('http://strava.com') self._win.hide()
def setup_webview(self, webview): try: os.makedirs(BASE_PATH) except: pass session = WebKit.get_default_session() jar = Soup.CookieJarText.new(COOKIE_FILE, False) jar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session.add_feature(jar) WebKit.set_web_database_directory_path(DATABASE_PATH) settings = webview.get_settings() settings.props.enable_page_cache = True settings.props.enable_default_context_menu = False # for speed up settings.props.auto_load_images = False settings.props.enable_dns_prefetching = True webview.set_settings(settings)
def __init__(self): """развертываем интерфейс из interface.glade""" self.builder = Gtk.Builder() self.builder.add_from_file("interface.glade") # главное окно с аттрибутами self.window = self.builder.get_object("MainWindow") self.mapScrolledWindow = self.builder.get_object("MapScrolledWindows") self.listBox = self.builder.get_object("ListBox") self.traectoryFileChooserButton = self.builder.get_object( "TraectoryFileChooserButton") self.addTraectoryButton = self.builder.get_object("AddTraectoryButton") self.clearAllButton = self.builder.get_object("ClearAllButton") self.updateButton = self.builder.get_object("UpdateButton") self.clearAllButton.connect("clicked", self.clearAllButton_Click) self.addTraectoryButton.connect("clicked", self.addTraectoryButton_Click) self.updateButton.connect("clicked", self.updateButton_Click) self.window.connect("delete-event", self.delete_event) self.window.set_title("Webkit") self.webview = WebKit.WebView() self.webview.open("http://localhost:8000/drawingGPX.html" ) # если делать через file:///... то нельзя будет # сохранять куки self.mapScrolledWindow.add(self.webview) self.cookiejar = Soup.CookieJarText.new( "cookie.txt", False) # хрень для работы с куки self.cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) self.session = WebKit.get_default_session( ) # получаем текущую сессию от webkit self.session.add_feature( self.cookiejar) # и добавляем в нее хрень для работы с куки self.plots = [] # список с графиками self.dataWorker = DataWorker.DataWorker() # обработчик данных self.colorGenerator = TraectoryListBoxRow.DefaultColors.generator() self.window.show_all() Gtk.main()
def __init__(self, toolbar): self._toolbar = toolbar session = WebKit.get_default_session() cookie_jar = SoupGNOME.CookieJarSqlite(filename=os.path.join( env.get_profile_path(), 'social-help.cookies'), read_only=False) session.add_feature(cookie_jar) self._webview = WebKit.WebView() self._webview.set_full_content_zoom(True) self._webview.connect('resource-request-starting', self.__resource_request_starting_cb) self._webview.connect('notify::uri', self.__load_changed_cb) toolbar.update_back_forward(False, False) toolbar.connect('back-clicked', self.__back_cb) toolbar.connect('forward-clicked', self.__forward_cb) self._webview.show()
def __init__(self, toolbar): self._toolbar = toolbar session = WebKit.get_default_session() cookie_jar = SoupGNOME.CookieJarSqlite( filename=os.path.join(env.get_profile_path(), 'social-help.cookies'), read_only=False) session.add_feature(cookie_jar) self._webview = WebKit.WebView() self._webview.set_full_content_zoom(True) self._webview.connect('resource-request-starting', self.__resource_request_starting_cb) self._webview.connect('notify::uri', self.__load_changed_cb) toolbar.update_back_forward(False, False) toolbar.connect('back-clicked', self.__back_cb) toolbar.connect('forward-clicked', self.__forward_cb) self._webview.show()
def set_property(self, pname, pvalue): """Set a property for WebView or SoupSession """ pname = pname.replace("_", "-") sec = None for ptype, pnames in WEBVIEW_PROPERTY_TYPE.items(): if pname not in pnames: continue sec = WEBKIT_SECTION wk_views = self.current_webviews for wk_view in wk_views: wk_settings = wk_view.get_settings() wk_settings.set_property(pname, pvalue) break if sec is None: for ptype, pnames in SOUP_PROPERTY_TYPE.items(): if pname not in pnames: continue sec = SOUP_SECTION soup_session = WebKit.get_default_session() if pname == "enable-disk-cache": if pvalue: self.load_soup_cache(soup_session) else: self.unload_soup_cache(soup_session) sb = self.builder.get_object("spinbutton_cache_size") sb.props.sensitive = pvalue elif pname == "enable-persistent-cookie": if pvalue: self.load_soup_cookiejar(soup_session) else: self.unload_soup_cookiejar(soup_session) elif pname == "cache-size": cache = self.get_soup_cache(soup_session) if cache: cache.set_max_size(pvalue * 1024 * 1024) elif pname in ["enable-do-not-track"]: pass else: soup_session.set_property(pname, pvalue) break if sec is not None: self.config.set(sec, pname, pvalue)
def __init__(self): Gtk.Window.__init__(self) screen = Gdk.Screen.get_default() self.set_default_size(screen.get_width(), screen.get_height()) # Hide scrollbars style_provider = Gtk.CssProvider() css = "GtkScrollbar{background-color:#000;-GtkRange-slider-width:0;" \ "-GtkRange-trough-border:0;" \ "-GtkScrollbar-has-backward-stepper:false;" \ "-GtkScrollbar-has-forward-stepper:false}" style_provider.load_from_data(css) Gtk.StyleContext.add_provider_for_screen( screen, style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) self.fullscreen() self.connect("delete-event", Gtk.main_quit) self.timeout_id = GObject.timeout_add(POLL_DELAY, self.update, None) self.session = WebKit.get_default_session() self.session.add_feature(Soup.CookieJar()) self.webview = WebKit.WebView() self.webview.set_full_content_zoom(True) self.webview.connect_after('notify::load-status', self._on_load_finished) scrolled_window = Gtk.ScrolledWindow() scrolled_window.add(self.webview) self.add(scrolled_window) self.last_update = 0 self.website = Website(**default_website) self.load_website() self.show_all() cursor = Gdk.Cursor.new(Gdk.CursorType.BLANK_CURSOR) self.get_window().set_cursor(cursor)
def webkit_set_proxy_uri(scheme, host, port, user=None, passwd=None): try: session = WebKit.get_default_session() session.set_property("max-conns", 3) session.set_property("max-conns-per-host", 1) if host: proxy_uri = Soup.URI() proxy_uri.set_scheme(str(scheme)) proxy_uri.set_host(str(host)) if port: proxy_uri.set_port(int(port)) if user: proxy_uri.set_user(str(user)) if passwd: proxy_uri.set_password(str(passwd)) session.set_property("proxy-uri", proxy_uri) return True except: exctype, value = sys.exc_info()[:2] print "error: webkit_set_proxy_uri: (%s, %s)" % (exctype, value) return False
window = gtk.Window() window.set_resizable(True) window.set_default_size(350, 580) window.connect("delete_event", lambda w, e: False) window.connect("destroy", lambda w: gtk.main_quit()) scrolled = gtk.ScrolledWindow(None, None) webview = webkit.WebView() scrolled.add(webview) window.add(scrolled) window.show_all() # hook up a cookie jar # http://stackoverflow.com/a/39296977/5228520 cookiejar = soup.CookieJarText.new('', False) cookiejar.set_accept_policy(soup.CookieJarAcceptPolicy.ALWAYS) session = webkit.get_default_session() session.add_feature(cookiejar) # open google page to request auth code # see https://github.com/tdryer/hangups/issues/260#issuecomment-246578670 # and https://github.com/tdryer/hangups/issues/260#issuecomment-247512300 # thanks dequis and hastebrot! get_params = { 'hl': 'en', 'scope': 'https://www.google.com/accounts/OAuthLogin', 'client_id': '936475272427.apps.googleusercontent.com', } uri_entrypoint = 'https://accounts.google.com/o/oauth2/programmatic_auth?' + urllib.urlencode( get_params) webview.open(uri_entrypoint)
def load_cookies(): cookiejar = Soup.CookieJarText.new(cookie_path, False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar)
def __init__(self, width, height): # create the window Gtk.Window.__init__(self) splitter = Gtk.Paned(orientation=Gtk.Orientation.VERTICAL) splitter.show() # create the widget container vbox = Gtk.VBox(homogeneous=False) self.add(splitter) vbox.show() splitter.add1(vbox) # create the menu file_menu = Gtk.Menu() accel_group = Gtk.AccelGroup() self.add_accel_group(accel_group) quit_item = Gtk.MenuItem() quit_item.set_label('_Quit') quit_item.set_use_underline(True) accel = Gtk.accelerator_parse('<Control>q') quit_item.add_accelerator('activate', accel_group, accel[0], accel[1], Gtk.AccelFlags.VISIBLE) quit_item.show() quit_item.connect('activate', self.quit) file_menu.append(quit_item) quit_item.show() menu_bar = Gtk.MenuBar() vbox.pack_start(menu_bar, False, False, 0) menu_bar.show() file_item = Gtk.MenuItem() file_item.set_label('_File') file_item.set_use_underline(True) file_item.show() file_item.set_submenu(file_menu) menu_bar.append(file_item) #Settings #self.settings = Settings("com.dz0ny.ubuntu-si-welcome") # create the WebView self.scroller = Gtk.ScrolledWindow() # Enables Cookies session = WebKit.get_default_session() cache = os.path.join(xdg_data_home(), 'com.dz0ny.ubuntu-si-welcome') cookie_jar = Soup.CookieJarText.new(os.path.join(cache, 'WebkitSession'), False) session.add_feature(cookie_jar) session.props.max_conns_per_host = 8 self.webview = WebKit.WebView() self.scroller.add(self.webview) self.webview.props.settings.enable_default_context_menu = False settings = self.webview.get_settings() settings.set_property("enable-plugins", False) settings.set_property('javascript-can-open-windows-automatically', True) settings.set_property('enable-universal-access-from-file-uris', True) settings.set_property('enable-developer-extras', False) self.webview_inspector = self.webview.get_inspector() self.webview_inspector.connect('inspect-web-view', self.inspect_webview) self.inspector_window = Gtk.Window() self.webview.show() self.scroller.show() # and use that for sizing self.set_size_request(width, height) # add the webkit window vbox.pack_start(self.scroller, True, True, 0) self.webview.connect("navigation-policy-decision-requested", self._on_new_window) #self.webview.connect("console-message", self._on_console_message) # a possible way to do IPC (script or title change) self.webview.connect("script-alert", self._on_script_alert) self.webview.connect("title-changed", self._on_title_changed) html_file = """%s/web_app/public/index.html""" % get_data_path() self.webview.open(html_file)
def unconfig_soup(self): """Load config values to a soup session""" soup_session = WebKit.get_default_session() soup_session.disconnect(soup_session.request_queued_cid) self.unload_soup_cache(soup_session)
def __init__(self, handle): activity.Activity.__init__(self, handle) _logger.debug('Starting the web activity') session = WebKit.get_default_session() session.set_property('accept-language-auto', True) session.set_property('ssl-use-system-ca-file', True) session.set_property('ssl-strict', False) # By default, cookies are not stored persistently, we have to # add a cookie jar so that they get saved to disk. We use one # with a SQlite database: cookie_jar = SoupGNOME.CookieJarSqlite(filename=_cookies_db_path, read_only=False) session.add_feature(cookie_jar) _seed_xs_cookie(cookie_jar) # FIXME # downloadmanager.remove_old_parts() self._force_close = False self._tabbed_view = TabbedView() self._tabbed_view.connect('focus-url-entry', self._on_focus_url_entry) self._tabbed_view.connect('switch-page', self.__switch_page_cb) self._tray = HTray() self.set_tray(self._tray, Gtk.PositionType.BOTTOM) self._primary_toolbar = PrimaryToolbar(self._tabbed_view, self) self._edit_toolbar = EditToolbar(self) self._view_toolbar = ViewToolbar(self) self._primary_toolbar.connect('add-link', self._link_add_button_cb) self._primary_toolbar.connect('go-home', self._go_home_button_cb) self._primary_toolbar.connect('go-library', self._go_library_button_cb) self._primary_toolbar.connect('set-home', self._set_home_button_cb) self._primary_toolbar.connect('reset-home', self._reset_home_button_cb) self._edit_toolbar_button = ToolbarButton( page=self._edit_toolbar, icon_name='toolbar-edit') self._primary_toolbar.toolbar.insert( self._edit_toolbar_button, 1) view_toolbar_button = ToolbarButton( page=self._view_toolbar, icon_name='toolbar-view') self._primary_toolbar.toolbar.insert( view_toolbar_button, 2) self._primary_toolbar.show_all() self.set_toolbar_box(self._primary_toolbar) self.set_canvas(self._tabbed_view) self._tabbed_view.show() self.model = Model() self.model.connect('add_link', self._add_link_model_cb) self.connect('key-press-event', self._key_press_cb) if handle.uri: self._tabbed_view.current_browser.load_uri(handle.uri) elif not self._jobject.file_path: # TODO: we need this hack until we extend the activity API for # opening URIs and default docs. self._tabbed_view.load_homepage() self.messenger = None self.connect('shared', self._shared_cb) # Get the Presence Service self.pservice = presenceservice.get_instance() try: name, path = self.pservice.get_preferred_connection() self.tp_conn_name = name self.tp_conn_path = path self.conn = telepathy.client.Connection(name, path) except TypeError: _logger.debug('Offline') self.initiating = None if self.get_shared_activity() is not None: _logger.debug('shared: %s', self.get_shared()) # We are joining the activity _logger.debug('Joined activity') self.connect('joined', self._joined_cb) if self.get_shared(): # We've already joined self._joined_cb() else: _logger.debug('Created activity') # README: this is a workaround to remove old temp file # http://bugs.sugarlabs.org/ticket/3973 self._cleanup_temp_files()
def __init__(self, start_url=TTABLE_URI, print_divs=False, print_html=False, print_regex=False, print_ttable=False, *a, **kw): super(MainWindow, self).__init__(*a, **kw) self.start_url = start_url self.print_divs = print_divs self.print_html = print_html self.print_regex = print_regex self.start_url = start_url self.print_ttable = print_ttable self.r = Gtk.Builder() self.r.add_from_file( os.path.join(os.path.dirname(os.path.realpath(__file__)), "scraper.ui")) self.r.connect_signals(self) cookiejar = self.get_cookiejar() if cookiejar: session = WebKit.get_default_session() session.add_feature(cookiejar) self.webview = WebKit.WebView() scrolledwindow = Gtk.ScrolledWindow() self.add(scrolledwindow) #self.r.get_object("scrolledwindow") scrolledwindow.add(self.webview) self.webview.connect("title-changed", self.on_title_changed) self.webview.connect("load-started", self.on_load_started) self.webview.connect("load-finished", self.on_load_finished) #self.webview.connect("icon-loaded", self.on_icon_loaded) self.ui_home() self.scrape_btn = self.r.get_object("scrape_button") self.scrape_btn.set_tooltip_text(SCRAPE_TTIP) self.r.get_object("warningicon").hide() self.hbar = self.r.get_object("headerbar") self.hbar.pack_start(self.scrape_btn) # self.hbar.pack_end(self.r.get_object("about_button")) self.hbar.pack_end(self.r.get_object("home_button")) self.hbar.pack_end(self.r.get_object("refresh_button")) self.hbar.pack_end(self.r.get_object("goto_button")) self.popover = Gtk.Popover() self.popover.set_position(Gtk.PositionType.TOP) self.popover.set_relative_to(self.r.get_object("goto_button")) pvbox = Gtk.Box() pvbox.set_orientation(Gtk.Orientation.VERTICAL) pvbox.add(Gtk.Label("Go to address")) pbox = Gtk.Box() pvbox.add(pbox) pbox.set_spacing(5) pvbox.set_property("margin", 10) pbox.set_orientation(Gtk.Orientation.HORIZONTAL) pbox.set_spacing(5) self.goto_entry = Gtk.Entry() self.goto_entry.set_input_purpose(Gtk.InputPurpose.URL) self.goto_entry.set_property("shadow_type", Gtk.ShadowType.NONE) self.goto_entry.set_width_chars(50) self.goto_entry.connect("activate", self.ui_do_goto) pbox.add(self.goto_entry) pbox.add(self.r.get_object("do_goto_button")) self.popover.add(pvbox) # self.win = self.r.get_object("window") # self.win.set_decorated(False) self.set_titlebar(self.hbar) self.set_default_size(1000, 600) # self.maximize() self.set_gravity(Gdk.Gravity.CENTER) self.set_position(Gtk.WindowPosition.CENTER_ALWAYS) self.show_all()
metavar="SLIDESHOW", default=default_path) (options, args) = parser.parse_args() options.path = os.path.abspath(options.path) if os.path.exists(options.path) == False: print( "\033[91m * Please build the slideshow content first by using the make command * \033[0m" ) sys.exit() Gdk.threads_init() # Set default SSL CA file for secure communication with web services. # This is important, because libsoup is not secure by default. soup_session = WebKit.get_default_session() soup_session.set_property('ssl-strict', True) soup_session.set_property('ssl-use-system-ca-file', True) slideshow_window = Gtk.Window() slideshow_window.set_title("Ubiquity Slideshow with Webkit") slideshow_window.connect('destroy', Gtk.main_quit) slideshow_window.set_resizable(False) slideshow_container = Gtk.VBox() slideshow_window.add(slideshow_container) slideshow = SlideshowViewer(options.path, locale=options.locale, rtl=options.rtl,
if namespace.webapp:# start web application mode view = WebKit.WebView() # view.connect("navigation-requested", navrequest) browser_settings = view.get_settings() #browser_settings.set_property('user-agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.1') browser_settings.set_property("enable-media-stream",True) browser_settings.set_property("enable-mediasource",True) view.set_settings(browser_settings) cookiejar = Soup.CookieJarText.new(namespace.apppath + "/.cookies.txt", False) cookiejar.set_accept_policy(Soup.CookieJarAcceptPolicy.ALWAYS) session = WebKit.get_default_session() session.add_feature(cookiejar) sw = Gtk.ScrolledWindow() sw.connect("key_press_event", browser_key_press) sw.add(view) # hbox=Gtk.HBox(); vbox = Gtk.VBox() vbox.add(sw) win = Gtk.Window()
class GIXMLHttpRequest(GIXMLHttpRequestEventTarget): '''XMLHttpRequest Level 2 http://www.w3.org/TR/XMLHttpRequest/''' UNSENT = 0 OPENED = 1 HEADERS_RECEIVED = 2 LOADING = 3 DONE = 4 ResponseType = set(['', 'arraybuffer', 'blob', 'document', 'json', 'text']) _app = None _msg = None _meta = { '_session': WebKit.get_default_session(), 'source-origin': 'about:blank', 'upload': None, 'status': 0, 'status-text': '', 'ready-state': UNSENT, 'response-type': '', 'response-text': '', 'anonymous-flag': None, 'send-flag': None, 'error-flag': None, 'synchronous-flag': None, 'request-method': 'GET', 'request-url': 'about:blank', 'request-username': None, 'request-password': None, 'author-request-headers': None, 'request-entity-body': None, 'upload-complete-flag': None, 'upload-events-flag': None, 'credentials-flag': None, 'force-preflight-flag': None, 'cross-origin-request-status': None, 'timeout': 0, } #TODO: properties ... onreadystatechange = None response = None #ro, any responseXML = None #DOMDocument (or XMLDOC-thing) @property def timeout(self): return self._meta['timeout'] @timeout.setter def timeout(self, timeout): #TODO: more to this? self._meta['timeout'] = timeout @property def withCredentials(self): return self._meta['credentials-flag'] @withCredentials.setter def withCredentials(self, withCredentials): #TODO: more to this? self._meta['credentials-flag'] = withCredentials @property def responseText(self): return self._meta['response-text'] @property def upload(self): return self._meta['upload'] @property def status(self): return self._meta['status'] @property def statusText(self): return self._meta['status-text'] @property def readyState(self): return self._meta['ready-state'] @property def responseType(self): return self._meta['response-type'] @responseType.setter def responseType(self, responseType): if responseType not in self.ResponseType: raise TypeError('InvalidAccessError') if self.readyState in (self.LOADING, self.DONE): raise TypeError('InvalidStateError') #TODO: there are 1-2 more check, but really ... ? self._meta['response-type'] = responseType def __init__(self, app): self._app = app def open(self, method, url, async=True, user=None, password=None):
def _on_request(self, view, frame, resource, request, response): print (' on request', view, frame, resource, request, response) if request: message = request.get_message() # SoupMessage if resource: uri = request.get_uri() print (' Resource data:') print (' Data:', resource.get_data()) print (' URI:', uri) print (' MIME:', resource.get_mime_type()) print (' Frame:', resource.get_frame_name()) #print uri if self._env is None: print ('ENVIROMENT NONE ON REQUEST') return uri = request.get_uri() message = request.get_message() # SoupMessage print ('URI:' + str(uri)) u = urlparse(uri) if u.netloc != self._u.netloc: print ('netloc:' + str(u.netloc)) print ('self netloc:' + str(self._u.netloc)) return if u.scheme != self._u.scheme: print ('scheme:' + str(u.scheme)) print ('self scheme:' + str(self._u.scheme)) return if self._oauth: print ('oauth CALL FIRST TIME') """query = dict(parse_qsl(u.query)) if u.query and not query: query = {u.query: ''} baseurl = ''.join([u.scheme, '://', u.netloc, u.path]) print ('baseurl:' + str(baseurl)) method = message.method print ('method:' + str(method)) h = _oauth_header(self._oauth, method, baseurl, query)""" elif self._basic: # http://comments.gmane.org/gmane.os.opendarwin.webkit.gtk/1194 # http://webkitgtk.org/reference/webkitgtk/stable/WebKitSoupAuthDialog.html print (WebKit.get_default_session().new()) h = _basic_auth_header(self._basic) else: return print ('request message method:' + str(request.props.message.props.method)) print ('request message uri:' + str(request.props.message.props.uri)) print ('request message http_version:' + str(request.props.message.props.http_version)) print ('request message flags:' + str(request.props.message.props.flags)) print ('request message server_side:' + str(request.props.message.props.server_side)) print ('request message status_code:' + str(request.props.message.props.status_code)) print ('request message reason_phrase:' + str(request.props.message.props.reason_phrase)) print ('request message first_party:' + str(request.props.message.props.first_party)) print ('request message request_body:' + str(request.props.message.props.request_body)) print ('request message request_headers:' + str(request.props.message.props.request_headers)) print ('request message tls_certificate:' + str(request.props.message.props.tls_certificate)) print ('request message tls_errors:' + str(request.props.message.props.tls_errors)) # http://developer.gnome.org/libsoup/stable/SoupSession.html#SoupSession-authenticate # Removes all the headers listed in the Connection header. message.request_headers.clean_connection_headers() print ('request uri:' + str(request.props.uri)) for (key, value) in h.items(): print ('key:' + str(key)) print ('value:' + str(value)) message.request_headers.append(key, value) print('COOKIES' + str(Soup.cookies_from_request(message))) print('AUTH' + str(message.request_headers.get("Authorization"))) print('Referer' + str(message.request_headers.get("Referer"))) print('Connection' + str(message.request_headers.get("Connection"))) print('Content-Type' + str(message.request_headers.get("Content-Type"))) print('Timeout' + str(message.request_headers.get("Timeout"))) print('Accept' + str(message.request_headers.get("Accept"))) # http://developer.gnome.org/libsoup/stable/SoupMessage.html print ('STATUS HTTP STATUS' + str(request.props.message.get_https_status())) print ('STATUS HTTP VERSION' + str(request.props.message.get_http_version())) print ('STATUS HTTP URI' + str(request.props.message.get_uri())) print ('STATUS HTTP ADDRESS' + str(request.props.message.get_address())) print ('STATUS HTTP FLAGS' + str(request.props.message.get_flags())) print ('STATUS KEEPALIVE' + str(request.props.message.is_keepalive())) print ('STATUS get_first_party' + str(request.props.message.get_first_party())) print ('STATUS get_' + str(request.props.message.props.request_headers.get_list(str(Soup.MessageHeadersType.RESPONSE)))) """SoupMessageHeaders
def finish_initializing(self, builder): # pylint: disable=E1002 """Set up the main window""" super(LightreadWindow, self).finish_initializing(builder) # We'll need to keep track of the indicator and handler later, so declare them here self.indicator = None self.window_close_handler = None self.AboutDialog = AboutLightreadDialog self.scroller = self.builder.get_object("scroller") #Enables Cookies session = WebKit.get_default_session() cache = os.path.join(xdg_data_home, 'com.caffeinatedcode.lightread') cookie_jar = Soup.CookieJarText.new(os.path.join(cache, 'WebkitSession'), False) session.add_feature(cookie_jar) session.props.max_conns_per_host = 8 self.webview = WebKit.WebView() self.scroller.add(self.webview) self.webview.props.settings.enable_default_context_menu = False self.webviewsettings = self.webview.get_settings() self.webviewsettings.set_property("javascript-can-open-windows-automatically", True) self.webviewsettings.set_property("enable-universal-access-from-file-uris", True) self.webviewsettings.set_property("enable-developer-extras", True) self.webview.load_uri(get_media_file('app/index.html')) self.webview_inspector = self.webview.get_inspector() self.webview_inspector.connect('inspect-web-view', self.inspect_webview) self.inspector_window = Gtk.Window() self.webview.show() #Menubar self.add = self.builder.get_object("add") self.refresh = self.builder.get_object("refresh") self.star = self.builder.get_object("star") self.read = self.builder.get_object("read") self.logout = self.builder.get_object("logout") self.next_article = self.builder.get_object("next-article") self.prev_article = self.builder.get_object("prev-article") self.filter_all = self.builder.get_object("filter-all") self.filter_unread = self.builder.get_object("filter-unread") self.filter_starred = self.builder.get_object("filter-starred") # Unity Support Notify.init('Lightread') self.notification = Notify.Notification.new('Lightread', '', '/usr/share/icons/hicolor/128x128/apps/lightread.png') try: launcher = Unity.LauncherEntry.get_for_desktop_id("extras-lightread.desktop") ql = Dbusmenu.Menuitem.new() updatenews = Dbusmenu.Menuitem.new() updatenews.property_set(Dbusmenu.MENUITEM_PROP_LABEL, "Update News") updatenews.property_set_bool(Dbusmenu.MENUITEM_PROP_VISIBLE, True) ql.child_append(updatenews) launcher.set_property("quicklist", ql) except NameError: pass # Message Passing Stuff def reload_feeds(this, widget, data=None): self.webview.execute_script('cmd("refresh")') def menuexternal(this, widget, data=None): print(this) print(this.get_name()) self.webview.execute_script('cmd("' + this.get_name() + '")') def _navigation_requested_cb(view, frame, networkRequest): uri = networkRequest.get_uri() if uri[:26] != 'http://www.instapaper.com/': subprocess.Popen(['xdg-open', uri]) return 1 return def console_message_cb(widget, message, line, source): logger.debug('%s:%s "%s"' % (source, line, message)) return True def title_changed(widget, frame, title): if title != 'null': print title title = title.split("|") #Gets Data from Disk if title[0] == 'count': try: if int(title[1]) == 0: launcher.set_property("count_visible", False) self.set_title("Lightread") else: launcher.set_property("count_visible", True) self.set_title(title[1] + " - Lightread") launcher.set_property("count", int(title[1])) except UnboundLocalError: pass elif title[0] == 'notify': # Update notification and show only if not changed and window not focused if self.notification.get_property('body') != title[2]: if self.is_active() is not True: self.notification.set_property('body', title[2]) self.notification.show() elif title[0] == 'copy': clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) clipboard.set_text(title[1], -1) clipboard.store() elif title[0] == 'gwibber': if sharingsupport: subprocess.call(["/usr/bin/gwibber-poster", "--message", title[1]]) elif title[0] == 'settings': settings_json = json.loads(title[1]) if settings_json.get('indicators') is True: if self.indicator is None: self.indicator = LightreadIndicator(self) self.indicator.show() elif settings_json.get('indicators') is False and self.indicator is not None: # indicator set to false but was already created: hide it self.indicator.hide() # if settings background true and not self.is connected delete-event if settings_json.get('background') is True and self.window_close_handler is None: self.window_close_handler = self.connect('delete-event', self._on_delete_event) elif settings_json.get('background') is False and self.window_close_handler is not None: self.disconnect(self.window_close_handler) self.window_close_handler = None elif title[0] == 'feed_count': if self.indicator is not None: feed_json = json.loads(title[1]) count = int(feed_json['count']) if count > 0: self.indicator.add_indicator(urllib.unquote(feed_json['id']), urllib.unquote(feed_json['title']), count) else: self.indicator.remove_indicator(urllib.unquote(feed_json['id'])) # Connects to WebView self.webview.connect('title-changed', title_changed) self.webview.connect('navigation-requested', _navigation_requested_cb) self.webview.connect('console-message', console_message_cb) self.add.connect("activate", menuexternal, None) self.refresh.connect("activate", menuexternal, None) self.star.connect("activate", menuexternal, None) self.read.connect("activate", menuexternal, None) self.logout.connect("activate", menuexternal, None) self.next_article.connect("activate", menuexternal, None) self.prev_article.connect("activate", menuexternal, None) self.filter_all.connect("activate", menuexternal, None) self.filter_unread.connect("activate", menuexternal, None) self.filter_starred.connect("activate", menuexternal, None) try: updatenews.connect("item-activated", reload_feeds, None) except UnboundLocalError: pass