def _do_add_parse_bits(self, node):
# Set all defaults if the properties have one registered
xmlprops = self._all_xml_props()
childprops = self._all_child_props()
for prop in xmlprops.values():
prop._set_default(self)
# Set up preferred XML ordering
do_order = self._proporder[:]
for key in reversed(self._XML_PROP_ORDER):
if key not in xmlprops and key not in childprops:
raise RuntimeError("programming error: key '%s' must be "
"xml prop or child prop" % key)
if key in do_order:
do_order.remove(key)
do_order.insert(0, key)
elif key in childprops:
do_order.insert(0, key)
for key in childprops.keys():
if key not in do_order:
do_order.append(key)
# Alter the XML
for key in do_order:
if key in xmlprops:
xmlprops[key]._set_xml(self, self._propstore[key], node)
elif key in childprops:
for obj in util.listify(getattr(self, key)):
obj._add_parse_bits(node)
def enable_polling(self, column):
# pylint: disable=redefined-variable-type
if column == COL_GUEST_CPU:
widgn = ["menu_view_stats_guest_cpu", "menu_view_stats_host_cpu"]
do_enable = self.config.get_stats_enable_cpu_poll()
if column == COL_DISK:
widgn = "menu_view_stats_disk"
do_enable = self.config.get_stats_enable_disk_poll()
elif column == COL_NETWORK:
widgn = "menu_view_stats_network"
do_enable = self.config.get_stats_enable_net_poll()
elif column == COL_MEM:
widgn = "menu_view_stats_memory"
do_enable = self.config.get_stats_enable_memory_poll()
for w in util.listify(widgn):
widget = self.widget(w)
tool_text = ""
if do_enable:
widget.set_sensitive(True)
else:
if widget.get_active():
widget.set_active(False)
widget.set_sensitive(False)
tool_text = _("Disabled in preferences dialog.")
widget.set_tooltip_text(tool_text)
def _find_keys(prefixes):
ret = []
for key, value in config.items():
for p in util.listify(prefixes):
if key.startswith(p):
ret.append((key, value))
break
return ret
def _parse_with_children(self, *args, **kwargs):
"""
Set new backing XML objects in ourselves and all our child props
"""
self._xmlstate._parse(*args, **kwargs)
for propname in self._all_child_props():
for p in util.listify(getattr(self, propname, [])):
p._xmlstate._parse(None, self._xmlstate.xml_node)
def _find_keys(prefixes):
ret = []
for key, value in config.items():
for p in util.listify(prefixes):
if key.startswith(p):
ret.append((key, value))
break
return ret
def __init__(self, child_classes, relative_xpath=".", is_single=False):
self.child_classes = util.listify(child_classes)
self.relative_xpath = relative_xpath
self.is_single = is_single
self._propname = None
if self.is_single and len(self.child_classes) > 1:
raise RuntimeError("programming error: Can't specify multiple "
"child_classes with is_single")
property.__init__(self, self._fget)
def _tuplify_lists(*args):
"""
Similar to zip(), but use None if lists aren't long enough, and
don't skip any None list entry
"""
args = [util.listify(l) for l in args]
maxlen = max([len(l) for l in args])
ret = []
for idx in range(maxlen):
tup = tuple()
for l in args:
tup += (idx >= len(l) and (None, ) or (l[idx], ))
ret.append(tup)
return ret
def _tuplify_lists(*args):
"""
Similar to zip(), but use None if lists aren't long enough, and
don't skip any None list entry
"""
args = [util.listify(l) for l in args]
maxlen = max([len(l) for l in args])
ret = []
for idx in range(maxlen):
tup = tuple()
for l in args:
tup += (idx >= len(l) and (None,) or (l[idx],))
ret.append(tup)
return ret
def new_setter(self, val, *args, **kwargs):
# Do this regardless, for validation purposes
fset(self, val, *args, **kwargs)
if not self._xml_node:
return
# Convert from API value to XML value
val = fget(self)
if set_converter:
val = set_converter(self, val)
elif default_converter and val == "default":
val = default_converter(self)
nodexpath = xpath
if xml_set_xpath:
nodexpath = xml_set_xpath(self)
if nodexpath is None:
return
nodes = util.listify(
_get_xpath_node(self._xml_ctx, nodexpath, is_multi))
xpath_list = nodexpath
if xml_set_list:
xpath_list = xml_set_list(self)
node_map = _tuplify_lists(nodes, val, xpath_list)
for node, val, usexpath in node_map:
if node:
usexpath = node.nodePath()
if val not in [None, False]:
if not node:
node = _build_xpath_node(self._xml_node, usexpath)
if val is True:
# Boolean property, creating the node is enough
pass
else:
node.setContent(util.xml_escape(str(val)))
else:
_remove_xpath_node(self._xml_node, usexpath)
def new_setter(self, val, *args, **kwargs):
# Do this regardless, for validation purposes
fset(self, val, *args, **kwargs)
if not self._xml_node:
return
# Convert from API value to XML value
val = fget(self)
if set_converter:
val = set_converter(self, val)
elif default_converter and val == "default":
val = default_converter(self)
nodexpath = xpath
if xml_set_xpath:
nodexpath = xml_set_xpath(self)
if nodexpath is None:
return
nodes = util.listify(_get_xpath_node(self._xml_ctx,
nodexpath, is_multi))
xpath_list = nodexpath
if xml_set_list:
xpath_list = xml_set_list(self)
node_map = _tuplify_lists(nodes, val, xpath_list)
for node, val, usexpath in node_map:
if node:
usexpath = node.nodePath()
if val not in [None, False]:
if not node:
node = _build_xpath_node(self._xml_node, usexpath)
if val is True:
# Boolean property, creating the node is enough
pass
else:
node.setContent(util.xml_escape(str(val)))
else:
_remove_xpath_node(self._xml_node, usexpath)
def _set_child_xpaths(self):
"""
Walk the list of child properties and make sure their
xpaths point at their particular element
"""
typecount = {}
for propname, xmlprop in self._all_child_props().items():
for obj in util.listify(getattr(self, propname)):
idxstr = ""
if not xmlprop.is_single:
class_type = obj.__class__
if class_type not in typecount:
typecount[class_type] = 0
typecount[class_type] += 1
idxstr = "[%d]" % typecount[class_type]
prop_path = xmlprop.get_prop_xpath(self, obj)
obj._set_parent_xpath(self.get_root_xpath())
obj._set_relative_object_xpath(prop_path + idxstr)
def new_getter(self, *args, **kwargs):
val = None
getval = fget(self, *args, **kwargs)
if not self._xml_node:
return getval
if default_converter and getval == "default":
return getval
usexpath = xpath
if xml_get_xpath:
usexpath = xml_get_xpath(self)
if usexpath is None:
return getval
nodes = util.listify(_get_xpath_node(self._xml_ctx, usexpath,
is_multi))
if nodes:
ret = []
for node in nodes:
val = node.content
if get_converter:
val = get_converter(self, val)
elif is_bool:
val = True
if not is_multi:
return val
# If user is querying multiple nodes, return a list of results
ret.append(val)
return ret
elif is_bool:
return False
elif get_converter:
getval = get_converter(self, None)
return getval
def new_getter(self, *args, **kwargs):
val = None
getval = fget(self, *args, **kwargs)
if not self._xml_node:
return getval
if default_converter and getval == "default":
return getval
usexpath = xpath
if xml_get_xpath:
usexpath = xml_get_xpath(self)
if usexpath is None:
return getval
nodes = util.listify(_get_xpath_node(self._xml_ctx,
usexpath, is_multi))
if nodes:
ret = []
for node in nodes:
val = node.content
if get_converter:
val = get_converter(self, val)
elif is_bool:
val = True
if not is_multi:
return val
# If user is querying multiple nodes, return a list of results
ret.append(val)
return ret
elif is_bool:
return False
elif get_converter:
getval = get_converter(self, None)
return getval
def _set_relative_object_xpath(self, xpath):
self._xmlstate.set_relative_object_xpath(xpath)
for propname in self._all_child_props():
for p in util.listify(getattr(self, propname, [])):
p._set_parent_xpath(self.get_root_xpath())
def _build_node_list(self, xmlbuilder, xpath):
"""
Build list of nodes that the passed xpaths reference
"""
nodes = _get_xpath_node(xmlbuilder._xmlstate.xml_ctx, xpath)
return util.listify(nodes)