コード例 #1
0
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)
コード例 #2
0
ファイル: webkit.py プロジェクト: pombredanne/shop
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)
コード例 #3
0
    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])
コード例 #4
0
    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/')
コード例 #5
0
ファイル: AppWindow.py プロジェクト: vk2r/Fogger
 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
コード例 #6
0
    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
コード例 #7
0
ファイル: utils.py プロジェクト: hermelin/hermelin-universal
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
コード例 #8
0
ファイル: messenger.py プロジェクト: Semmu/messenger
	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()
コード例 #9
0
ファイル: viewhelp.py プロジェクト: icarito/sugar
    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)
コード例 #10
0
ファイル: vk_service.py プロジェクト: Cgruppo/foobnix
    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
コード例 #11
0
    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)
コード例 #12
0
 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)
コード例 #13
0
ファイル: utils.py プロジェクト: xiaokyun/Hotot
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
コード例 #14
0
    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)
コード例 #15
0
 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)
コード例 #16
0
ファイル: pibrowser.py プロジェクト: uemurax/pibrowser
 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)
コード例 #17
0
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)
コード例 #18
0
ファイル: slacker.py プロジェクト: benfairless/slacker
    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)
コード例 #19
0
ファイル: __init__.py プロジェクト: 0x0001/ubuntu-tweak
    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)
コード例 #20
0
ファイル: widgets.py プロジェクト: nagisa/Feeds
    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)
コード例 #21
0
    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))
コード例 #22
0
ファイル: __init__.py プロジェクト: yeyueis1/ubuntu-tweak
    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)
コード例 #23
0
ファイル: webkit_test.py プロジェクト: zepto/webbrowser2
    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))
コード例 #24
0
ファイル: stravasync.py プロジェクト: adamsutton/bryton-sync
    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()
コード例 #25
0
ファイル: stravasync.py プロジェクト: adamsutton/bryton-sync
  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()
コード例 #26
0
ファイル: cgv.py プロジェクト: xncbf/cgv_reservation
    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)
コード例 #27
0
ファイル: testWebOSMMap.py プロジェクト: ArtemZaZ/OSMPyHTML
    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()
コード例 #28
0
    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()
コード例 #29
0
ファイル: viewhelp_webkit1.py プロジェクト: AbrahmAB/sugar
    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()
コード例 #30
0
    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)
コード例 #31
0
    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)
コード例 #32
0
ファイル: utils.py プロジェクト: sarim/Hotot
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
コード例 #33
0
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)
コード例 #34
0
ファイル: mobile_gtk3.py プロジェクト: mhielscher/md-twit
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)
コード例 #35
0
    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)
コード例 #36
0
    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)
コード例 #37
0
    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()
コード例 #38
0
ファイル: scraper.py プロジェクト: jacopo-j/PoliScraper
    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()
コード例 #39
0
ファイル: Slideshow.py プロジェクト: regisgouveia/core-apps
                  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,
コード例 #40
0
ファイル: webapp.py プロジェクト: MasterSoft24/webapp-gtk
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()

コード例 #41
0
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):
コード例 #42
0
        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
コード例 #43
0
ファイル: LightreadWindow.py プロジェクト: gmilby/LightRead
    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