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
