def gsettings_get(self):
""" Get value from gsettings. """
value = self.default
try:
# Bug in Gio, gir1.2-glib-2.0, Oneiric
# Onboard is accumulating open file handles
# at "/home/<user>/.config/dconf/<user>' when
# reading from gsettings before writing.
# Check with:
# lsof -w -p $( pgrep gio-test ) -Fn |sort|uniq -c|sort -n|tail
#value = self.settings[self.key]
if self.enum:
value = self.settings.get_enum(self.key)
elif self.type_string:
value = self.settings.get_value(self.key).unpack()
else:
_type = type(self.default)
if _type == str:
value = self.settings.get_string(self.key)
elif _type == int:
value = self.settings.get_int(self.key)
elif _type == float:
value = self.settings.get_double(self.key)
else:
value = self.settings[self.key]
except KeyError as ex:
_logger.error(_("Failed to get gsettings value. ") + \
unicode_str(ex))
return value
def load_system_defaults(self, paths):
"""
System default settings can be optionally provided for distribution
specific customization or branding.
They are stored in simple ini-style files, residing in a small choice
of directories. The last setting found in the list of paths wins.
"""
_logger.info(_format("Looking for system defaults in {paths}",
paths=paths))
filename = None
parser = configparser.SafeConfigParser()
try:
if sys.version_info.major == 2:
filename = parser.read(paths)
else:
filename = parser.read(paths, "UTF-8")
except configparser.ParsingError as ex:
_logger.error(_("Failed to read system defaults. " + \
unicode_str(ex)))
if not filename:
_logger.info(_("No system defaults found."))
else:
_logger.info(_format("Loading system defaults from {filename}",
filename=filename))
self._read_sysdef_section(parser)
def _list_to_dict(_list, key_type = str, num_values = 2):
""" Get dictionary from a gsettings list key """
if sys.version_info.major == 2:
_list = [unicode_str(x) for x in _list] # translate to unicode
return unpack_name_value_list(_list, key_type=key_type,
num_values = num_values)
def migrate_dconf_value(self, dconf_key, gskey):
""" Copy the value of dconf_key into the given gskey """
if not self._osk_dconf:
self._osk_dconf = osk.DConf()
try:
value = self._osk_dconf.read_key(dconf_key)
except (ValueError, TypeError) as e:
value = None
_logger.warning("migrate_dconf_value: {}".format(e))
if not value is None:
# Enums are stored as strings in dconf, convert them to int.
if gskey.enum:
value = gskey.enum.get(value, 0)
# Optionally convert from gsettings value to property value.
hook = _UNPACK_HOOK + gskey.prop
if hasattr(self, hook):
v = value
value = getattr(self, hook)(value)
_logger.info("migrate_dconf_value: {key} -> {path} {gskey}, value={value}" \
.format(key=dconf_key,
path=self.schema,
gskey=gskey.key, value=value))
try:
setattr(self, gskey.prop, value)
except Exception as ex:
_logger.error("Migrating dconf key failed: '{key}={value}'; "
"possibly due to incompatible dconf type; "
"skipping this key. "
"Exception: {exception}" \
.format(key=dconf_key, value=value,
exception=unicode_str(ex)))
def add_optional_child(self, type):
""" Add child ConfigObject or None if it's schema doesn't exist. """
try:
co = type(self)
self.children.append(co)
except SchemaError as e:
_logger.warning(unicode_str(e))
co = None
return co
def load(filename, is_system=False):
""" Load a color scheme and return it as a new object. """
color_scheme = None
f = open_utf8(filename)
try:
dom = minidom.parse(f).documentElement
name = dom.attributes["name"].value
# check layout format
format = ColorScheme.COLOR_SCHEME_FORMAT_LEGACY
if dom.hasAttribute("format"):
format = Version.from_string(dom.attributes["format"].value)
if format >= ColorScheme.COLOR_SCHEME_FORMAT_TREE: # tree format?
items = ColorScheme._parse_dom_node(dom, None, {})
else:
_logger.warning(_format( \
"Loading legacy color scheme format '{old_format}', "
"please consider upgrading to current format "
"'{new_format}': '{filename}'",
old_format = format,
new_format = ColorScheme.COLOR_SCHEME_FORMAT,
filename = filename))
items = ColorScheme._parse_legacy_color_scheme(dom)
if not items is None:
root = Root()
root.set_items(items)
color_scheme = ColorScheme()
color_scheme.name = name
color_scheme.filename = filename
color_scheme.is_system = is_system
color_scheme.root = root
#print(root.dumps())
except xml.parsers.expat.ExpatError as ex:
_logger.error(_format("Error loading color scheme '{filename}'. "
"{exception}: {cause}",
filename = filename,
exception = type(ex).__name__,
cause = unicode_str(ex)))
finally:
f.close()
return color_scheme
def load(filename, is_system=False):
""" Load a theme and return a new theme object. """
result = None
_file = open_utf8(filename)
try:
domdoc = minidom.parse(_file).documentElement
try:
theme = Theme()
node = domdoc.attributes.get("format")
format = Version.from_string(node.value) \
if node else Theme.THEME_FORMAT_INITIAL
theme.name = domdoc.attributes["name"].value
# "color_scheme" is the base file name of the color scheme
text = utils.xml_get_text(domdoc, "color_scheme")
if not text is None:
theme.color_scheme_basename = text
# get key label overrides
nodes = domdoc.getElementsByTagName("key_label_overrides")
if nodes:
overrides = nodes[0]
tuples = {}
for override in overrides.getElementsByTagName("key"):
key_id = override.attributes["id"].value
node = override.attributes.get("label")
label = node.value if node else ""
node = override.attributes.get("group")
group = node.value if node else ""
tuples[key_id] = (label, group)
theme.key_label_overrides = tuples
# read all other members
for name, _type, _default in Theme.attributes:
if not name in ["color_scheme_basename",
"key_label_overrides"]:
value = utils.xml_get_text(domdoc, name)
if not value is None:
if _type == "i":
value = int(value)
if _type == "d":
value = float(value)
if _type == "ad":
value = [float(s) for s in value.split(",")]
# upgrade to current file format
if format < Theme.THEME_FORMAT_1_1:
# direction was 0..360, ccw
# is now -180..180, cw
if name == "key_gradient_direction":
value = -(value % 360)
if value <= -180:
value += 360
setattr(theme, name, value)
theme.filename = filename
theme.is_system = is_system
theme.system_exists = is_system
result = theme
finally:
domdoc.unlink()
except (Exceptions.ThemeFileError,
xml.parsers.expat.ExpatError) as ex:
_logger.error(_format("Error loading theme '{filename}'. "
"{exception}: {cause}",
filename = filename,
exception = type(ex).__name__,
cause = unicode_str(ex)))
result = None
finally:
_file.close()
return result
def __str__(self):
message = unicode_str(self._message) + "\n"
if self.chained_exception:
message += "%s: %s" % (type(self.chained_exception).__name__,
unicode_str(self.chained_exception))
return message