def config_soup(self):
        """Load config values to a soup session"""
        soup_session = WebKit2.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)
Exemple #2
0
    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 = WebKit2.WebView()

        self.vbox.pack_start(self.web_view, False, False, 0)

        self.web_view.connect('resource-load-finished', self.on_load)
        session = WebKit2.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 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 = WebKit2.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 unconfig_soup(self):
        """Load config values to a soup session"""
        soup_session = WebKit2.get_default_session()
        soup_session.disconnect(soup_session.request_queued_cid)

        self.unload_soup_cache(soup_session)