tree 1e4d754e928f1906d8ef325bc7f15be3aa9172b5
parent 5147ed2f5c66369f6abdea0725c76e3de4c2c335
author Eric Williams <ericwill@redhat.com> 1527087103 -0400
committer Alexander Kurtakov <akurtako@redhat.com> 1528287903 -0400

Bug 394087: [Net] Migration from GConf to GSettings.

Use GSettings instead of GConf2 to fetch proxy settings from GNOME.
Instead it now uses the following GSettings schemas for proxies:

org.gnome.system.proxy
org.gnome.system.proxy.http
org.gnome.system.proxy.https
org.gnome.system.proxy.socks
org.gnome.system.proxy.ftp

You can get/set values for the keys in each of these schemas by running
gsettings [get/set] schema key value.

For example, to set the SOCKS proxy host, run: gsettings set
org.gnome.system.proxy.socks host <value>

To test in Eclipse, import the org.eclipse.core.net and
org.eclipse.core.net.linux.x86_64 projects into your workspace. Launch a
child Eclipse that depends on these two workspace plugins, and make sure
the child Eclipse launches with the argument:
-Dorg.eclipse.core.net.enableGnome

as this enables the GNOME proxy functionality. In the child Eclipse, go
to Window -> Preferences -> General -> Network connections. Selecting
the "native" combo option will pull in proxy/network settings as set via
GNOME.

Change-Id: I0f620275aa15205245ae4156d9ed63ebf20c3568
Signed-off-by: Eric Williams <ericwill@redhat.com>