# -*- coding: utf-8 -*-
# Editobj3
# Copyright (C) 2007-2014 Jean-Baptiste LAMY
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see .
"""editobj3.editor -- The main widget for object edition
"""
import locale
import editobj3, editobj3.introsp as introsp, editobj3.observe as observe, editobj3.undoredo as undoredo, editobj3.field
from editobj3.introsp import Inexistent
class PaneRepartitor(object):
def is_displayed_in_hierarchy_pane(self, attribute, o, field_class = None): return False
def is_displayed_in_attribute_pane(self, attribute, o, field_class = None): return True
class MultiGUIEditor(editobj3.field.MultiGUIWidget):
_Gtk_MODULE = "editobj3.editor_gtk"
_Qt_MODULE = "editobj3.editor_qt"
_HTML_MODULE = "editobj3.editor_html"
class BaseDialog(object):
def build_default_menubar(self):
self.file_menu = self.add_to_menu(self.menubar , 1, u"File")
self.close_menu= self.add_to_menu(self.file_menu, 0, u"Close", self.close_dialog)
self.edit_menu = self.add_to_menu(self.menubar , 1, u"Edit" , self.on_edit_menu)
self.undo_menu = self.add_to_menu(self.edit_menu, 0, u"Undo" , self.on_undo, accel = u"C-Z")
self.redo_menu = self.add_to_menu(self.edit_menu, 0, u"Redo" , self.on_redo, accel = u"C-Y")
def add_to_menu(self, menu, has_submenu, label, command = None, arg = None, accel = "", accel_enabled = 1, image = None, type = u"button", pos = -1): raise NotImplementedError
def add_separator_to_menu(self, menu, pos = -1): raise NotImplementedError
def set_menu_checked(self, menu, checked): raise NotImplementedError
def set_menu_enable (self, menu, enable): raise NotImplementedError
def set_menu_label (self, menu, label): raise NotImplementedError
def on_edit_menu(self, *args):
undo = self.undo_stack.can_undo()
redo = self.undo_stack.can_redo()
if undo: self.set_menu_enable(self.undo_menu, 1); self.set_menu_label(self.undo_menu, "%s %s" % (editobj3.TRANSLATOR(u"Undo"), undo.name))
else: self.set_menu_enable(self.undo_menu, 0); self.set_menu_label(self.undo_menu, editobj3.TRANSLATOR(u"Undo"))
if redo: self.set_menu_enable(self.redo_menu, 1); self.set_menu_label(self.redo_menu, "%s %s" % (editobj3.TRANSLATOR(u"Redo"), redo.name))
else: self.set_menu_enable(self.redo_menu, 0); self.set_menu_label(self.redo_menu, editobj3.TRANSLATOR(u"Redo"))
def on_undo(self, *args):
if self.undo_stack.can_undo(): self.undo_stack.undo()
def on_redo(self, *args):
if self.undo_stack.can_redo(): self.undo_stack.redo()
def close_dialog (self): self.on_dialog_closed()
def on_dialog_closed(self, *args): raise NotImplementedError
def set_default_size(self, w, h): raise NotImplementedError
def show(self): raise NotImplementedError
def main(self): raise NotImplementedError
class EditorDialog(MultiGUIEditor):
def __init__(self, gui = None, master = None, direction = "h", on_validate = None, edit_child_in_self = 1, undo_stack = None, on_close = None, menubar = True):
self.gui = gui or editobj3.GUI
self.on_validate = on_validate
self.on_close = on_close
self.undo_stack = undo_stack or undoredo.stack
self.editor_pane = EditorPane(gui, self, edit_child_in_self, self.undo_stack, direction)
if menubar: self.build_default_menubar()
def edit (self, o): return self.editor_pane.edit (o)
def edit_child(self, o): return self.editor_pane.edit_child(o)
def get_selected_object(self): return self.editor_pane.attribute_pane.o
class EditorTabbedDialog(MultiGUIEditor):
def __init__(self, gui, master = None, direction = "h", on_validate = None, edit_child_in_self = 1, undo_stack = None, on_close = None, menubar = True):
self.gui = gui or editobj3.GUI
self.on_validate = on_validate
self.on_close = on_close
self.undo_stack = undo_stack or undoredo.stack
self.direction = direction
self.edit_child_in_self = edit_child_in_self
self.editor_panes = {}
self.editor_pane = EditorPane(gui, self, edit_child_in_self, self.undo_stack, direction)
if menubar: self.build_default_menubar()
def add_tab(self, name, label, o = None):
self.editor_panes[name] = editor_pane = EditorPane(self.gui, self, self.edit_child_in_self, self.undo_stack, self.direction)
if not o is None: editor_pane.edit(o)
return editor_pane
def show_tab(self, editor_pane):
if editor_pane.func:
o = editor_pane.func()
editor_pane.edit(o)
def remove_tab(self, name): del self.editor_panes[name]
def get_current_editor_pane(self): raise NotImplementedError
def get_selected_object(self): return self.get_current_editor_pane().o
class EditorPane(MultiGUIEditor):
def __init__(self, gui, master, edit_child_in_self = 1, undo_stack = None, direction = "h"):
undo_stack = undo_stack or undoredo.stack
self.gui = gui
self.master = master
self.direction = direction
self.edit_child_in_self = edit_child_in_self
self.childhood_pane = ChildhoodPane(gui, self, undo_stack)
self.hierarchy_pane = HierarchyPane(gui, self, self.edit_child, undo_stack)
self.attribute_pane = AttributePane(gui, self, self.edit_child, undo_stack)
self.attribute_pane.pane_repartitor = self.hierarchy_pane
self.icon_pane = IconPane (gui, self)
self.hierarchy_pane.set_childhood_pane(self.childhood_pane)
def set_pane_repartitor(self, pane_repartitor):
self.hierarchy_pane.pane_repartitor = self.attribute_pane.pane_repartitor = pane_repartitor
def edit(self, o):
self.hierarchy_pane.edit(o)
self.icon_pane .edit(o)
self.attribute_pane.edit(o)
if self.hierarchy_pane.root_node and self.hierarchy_pane.root_node.can_have_children(): self._set_hierarchy_visible(1)
else: self._set_hierarchy_visible(0)
def edit_child(self, o, ignored_attrs = None):
self.on_edit_child(o)
if self.edit_child_in_self:
self.icon_pane .edit(o)
self.attribute_pane.edit(o, ignored_attrs)
def on_edit_child(self, o): pass
def _set_hierarchy_visible(self, visible): pass
class AttributePane(MultiGUIEditor, PaneRepartitor):
def __init__(self, gui, master, edit_child = None, undo_stack = None):
self.gui = gui
self.master = master
self.undo_stack = undo_stack or undoredo.stack
self.o = None
self.attributes = []
self.attr_2_attribute = {}
self.ignored_attrs = set()
self.pane_repartitor = self
if edit_child: self.edit_child = edit_child
def _re_edit(self): self.edit(self.o)
def _listener(self, o, type, new, old):
if type == "__class__": self.edit(None); self.edit(o)
elif type is object:
diffs = observe.diffdict(new, old, Inexistent)
for attr, new_val, old_val in diffs:
if (old_val is Inexistent) or (new_val is Inexistent):
self._re_edit()
return
need_updates = { attr for attr, new_val, old_val in diffs }
for attribute in self.property_attributes: need_updates.add(attribute.name)
for attr in need_updates:
field = self.fields.get(attr)
if field: field.update()
def _listener2(self, o, diffs):
from owlready2 import IRIS
diffs2 = []
for attr, new, old in diffs:
pred = IRIS.get(attr)
if pred: diffs2.append((pred.python_name, new, old))
else: diffs2.append((attr, new, old))
diffs = diffs2
for attr, new, old in diffs:
if (not attr in self.attr_2_attribute) and (old == []):
self._re_edit()
return
need_updates = { attr for attr, new_val, old_val in diffs }
need_updates.update(attribute.name for attribute in self.property_attributes)
need_updates.update(attribute.name for attribute in self.descr.property_attributes_of(self.o))
for attr in need_updates:
field = self.fields.get(attr)
if field: field.update()
def _destroyed(self, *args): observe.unobserve(self.o, self._listener)
def edit(self, o, ignored_attrs = None):
if not self.o is None:
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.unobserve(self.o, owlready2.observe.CollapsedListener(self._listener2))
else:
observe.unobserve(self.o, self._listener)
self.descr = introsp.description_for_object(o)
if ignored_attrs: self.ignored_attrs = ignored_attrs
elif self.ignored_attrs: self.ignored_attrs = set()
if o is None:
attributes = []
else:
if hasattr(o, "__edited__"): o.__edited__(self)
attributes = [attribute for attribute in self.descr.attributes_of(o) if not attribute.name in self.ignored_attrs]
if o and self.o and (self.attributes == attributes):
self.o = o
self.property_attributes = self.descr.property_attributes_of(o)
if not o is None:
for field in self.fields.values(): field.edit(o)
else:
if not self.o is None:
self._delete_all_fields()
self.o = o
self.property_attributes = self.descr.property_attributes_of(o)
self.attributes = attributes
self.attr_2_attribute = { attribute.name : attribute for attribute in attributes }
if not o is None:
self._set_nb_fields(len(attributes))
i = 0
self.fields = {}
for attribute in attributes:
field_class = attribute.field_class_for(o)
if field_class is editobj3.field.HiddenField: continue
if not self.pane_repartitor.is_displayed_in_attribute_pane(attribute, o, field_class): continue
self.fields[attribute.name] = self._new_field(attribute, field_class, attribute.unit_for(o), i)
i += 1
if not o is None:
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.observe(self.o, owlready2.observe.CollapsedListener(self._listener2))
else:
observe.observe(self.o, self._listener)
edit_child = edit
def _delete_all_fields(self): pass
def _set_nb_fields(self, nb): pass
def _new_field(self, attribute, field_class, unit, i): pass
class IconPane(MultiGUIEditor):
def __init__(self, gui, master):
self.master = master
self.o = None
self.descr = None
def edit(self, o):
if o is self.o: return
if not self.o is None:
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.unobserve(self.o, owlready2.observe.CollapsedListener(self._listener))
else:
observe.unobserve(self.o, self._listener)
self.o = o
self.descr = introsp.description_for_object(o)
if hasattr(o, "__edited__"): o.__edited__(self)
if not o is None:
self._update()
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.observe(self.o, owlready2.observe.CollapsedListener(self._listener))
else:
observe.observe(self.o, self._listener)
else: self._set_icon_filename_label_details("", "", "")
def _listener(self, o, type = None, new = None, old = None): self._update()
def _update(self):
self._set_icon_filename_label_details(self.descr.icon_filename_for(self.o), self.descr.label_for(self.o), self.descr.details_for(self.o))
def _set_icon_filename_label_details(self, icon_filename, label, details): pass
def _destroyed(self, *args):
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.unobserve(self.o, owlready2.observe.CollapsedListener(self._listener))
else:
observe.unobserve(self.o, self._listener)
def _not_empty(g):
try: g.__next__()
except StopIteration: return 0
return 1
class ChildhoodPane(MultiGUIEditor):
def __init__(self, gui, master, undo_stack = None, restrict_to_attribute = None):
self.undo_stack = undo_stack or undoredo.stack
self.restrict_to_attribute = restrict_to_attribute
self.hierarchy_pane = None
self.nodes = []
self.master = master
def edit(self, parent, attribute, o):
self.parent_o = parent
self.attribute = attribute
self.o = o
can_reorder = can_remove = can_add = False
if parent is o: # ObjectListField / flat list => edit the hidden "root" element
if attribute:
if isinstance(o, introsp.ObjectPack):
for i in range(len(o.objects)):
if attribute[i]:
if attribute[i].can_add_to (parent.objects[i]) and attribute[i].addable_values_to(parent.objects[i]): can_add = True
else:
can_add = attribute.can_add_to(parent) and attribute.addable_values_to(parent)
else:
if attribute:
if isinstance(o, introsp.ObjectPack):
for i in range(len(o.objects)):
if attribute[i]:
if attribute[i].can_reorder (parent.objects[i]): can_reorder = True
if attribute[i].can_remove_from(parent.objects[i]): can_remove = True
if attribute[i].can_add_to (parent.objects[i]) and attribute[i].addable_values_to(parent.objects[i]): can_add = True
else:
can_reorder = attribute.can_reorder(parent)
can_remove = attribute.can_remove_from(parent)
can_add = attribute.can_add_to(parent) and attribute.addable_values_to(parent)
if (not can_add) and not attribute:
for o_attribute in introsp.description_for_object(o).attributes_of(o):
if (o_attribute.can_add_to(o) and o_attribute.addable_values_to(o)):
can_add = True
break
self.set_button_visibilities(can_reorder, can_add, can_remove, can_reorder)
def set_button_visibilities(self, visible1, visible2, visible3, visible4): pass
def get_add_actions(self):
if self.restrict_to_attribute:
return [action
for action in introsp.description_for_object(self.o).actions_for(self.parent_o, self.attribute, self.o)
if isinstance(action, introsp.AddAction) and action.attribute == self.restrict_to_attribute]
else:
return [action
for action in introsp.description_for_object(self.o).actions_for(self.parent_o, self.attribute, self.o)
if self.hierarchy_pane.filter_add_action(action, self.parent_o, self.o, only_add = True)]
r = []
for action in introsp.description_for_object(self.o).actions_for(self.parent_o, self.attribute, self.o):
if isinstance(action, introsp.AddAction):
if isinstance(action, introsp.ActionOnAChild):
if self.hierarchy_pane.pane_repartitor.is_displayed_in_hierarchy_pane(action.attribute, self.parent_o):
r.append(action)
else:
if self.hierarchy_pane.pane_repartitor.is_displayed_in_hierarchy_pane(action.attribute, self.o):
r.append(action)
return r
def on_add(self, *args):
add_actions = self.get_add_actions()
if len(add_actions) == 0: return
elif len(add_actions) == 1: self.hierarchy_pane._action_activated(add_actions[0], self.parent_o, self.attribute, self.o)
else: self.hierarchy_pane.show_action_menu(add_actions)
def on_remove(self, *args):
introsp.description_for_object(self.parent_o).do_action(introsp._REMOVE_ACTION, self.undo_stack, self.hierarchy_pane.get_editor(), self.parent_o, self.attribute, self.o)
def on_move_up(self, *args):
introsp.description_for_object(self.parent_o).do_action(introsp._MOVE_UP_ACTION, self.undo_stack, self.hierarchy_pane.get_editor(), self.parent_o, self.attribute, self.o)
def on_move_down(self, *args):
introsp.description_for_object(self.parent_o).do_action(introsp._MOVE_DOWN_ACTION, self.undo_stack, self.hierarchy_pane.get_editor(), self.parent_o, self.attribute, self.o)
class HierarchyPane(MultiGUIEditor, PaneRepartitor):
Node = None
def __init__(self, gui, master, edit_child, undo_stack = None, restrict_to_attribute = None, flat_list = False):
self.gui = gui
self.master = master
self.edit_child = edit_child
self.o = None
self.root_node = None
self.undo_stack = undo_stack or undoredo.stack
self.childhood_pane = None
self.childhood_pane_parent = None
self.childhood_pane_attribute = None
self.restrict_to_attribute = restrict_to_attribute
self.flat_list = flat_list
self.pane_repartitor = self
def is_displayed_in_hierarchy_pane(self, attribute, o, field_class = None):
if not field_class: field_class = attribute.field_class_for(o)
return field_class.display_in_hierarchy_pane
def is_displayed_in_attribute_pane(self, attribute, o, field_class = None):
if not field_class: field_class = attribute.field_class_for(o)
return field_class.display_in_attribute_pane
def set_childhood_pane(self, childhood_pane, parent = None, attribute = None):
self.childhood_pane = childhood_pane
self.childhood_pane_parent = parent
self.childhood_pane_attribute = attribute
self.childhood_pane.hierarchy_pane = self
def _destroyed(self, *args):
if self.root_node: self.root_node.destroy()
def expand_object(self, o):
node = self.root_node.node_for_object(o)
if node: node.expand()
def select_object(self, o):
if isinstance(o, introsp.ObjectPack): self.select_node(self.root_node.node_for_object(o.objects[0]))
else: self.select_node(self.root_node.node_for_object(o))
def edit(self, o):
if o is self.o: return
if self.root_node: self.root_node.destroy()
self.o = o
self.descr = introsp.description_for_object(o)
self.root_node = self.Node(self, self.tree, None, o, self.restrict_to_attribute, self.flat_list)
if self.childhood_pane: self.childhood_pane.edit(self.childhood_pane_parent, self.childhood_pane_attribute, o)
def get_actions(self, parent_o, attribute, o):
return [action for action in introsp.description_for_object(o).actions_for(parent_o, attribute, o)
if self.filter_add_action(action, parent_o, o, only_add = False)]
def filter_add_action(self, action, parent_o, o, only_add = False):
if isinstance(action, introsp.AddAction):
if isinstance(action, introsp.ActionOnAChild):
if self.pane_repartitor.is_displayed_in_hierarchy_pane(action.attribute, parent_o): return True
else:
if self.pane_repartitor.is_displayed_in_hierarchy_pane(action.attribute, o): return True
else: return not only_add
def get_editor(self):
if isinstance(self.master, EditorPane):
if isinstance(self.master.master, EditorDialog): return self.master.master
else: return self.master
return self
def _action_activated(self, action, parent, attribute, o):
if isinstance(action, introsp.AddAction):
def callback(new_child):
if (not new_child is None) and self.selected_node:
if not isinstance(action, introsp.ActionOnAChild):
self.selected_node.expand()
for child_node in self.selected_node.children:
if child_node.o is new_child: self.select_node(child_node)
else:
for child_node in self.selected_node.parent.children:
if child_node.o is new_child: self.select_node(child_node)
extra = [callback]
else: extra = []
if isinstance(action, introsp.ActionOnAChild):
r = introsp.description_for_object(parent).do_action(action, self.undo_stack, self.get_editor(), parent, attribute, o, *extra)
else:
r = introsp.description_for_object(o ).do_action(action, self.undo_stack, self.get_editor(), o, *extra)
def show_action_menu(self, actions): pass
def get_ignored_attrs(self, nodes): return { node.attribute.inverse_attr for node in nodes if node.parent and node.attribute }
def _ordered(x):
if isinstance(x, set ): return list (x)
elif isinstance(x, frozenset): return tuple(x)
elif isinstance(x, dict ): return list (x.values())
return x
class HierarchyNode(object):
def __init__(self, hierarchy_pane, parent_node, attribute, o, restrict_to_attribute, flat_list):
self.hierarchy_pane = hierarchy_pane
self.descr = introsp.description_for_object(o)
self.attribute = attribute
self.o = o
self.o_has_any_children = 0
self.o_has_children = {}
self.o_children_getter = None
self.o_children = None
self.observeds = []
self.restrict_to_attribute = restrict_to_attribute
self.flat_list = flat_list
if attribute: self.inverse_attr = attribute.inverse_attr
else: self.inverse_attr = None
self._observe(self.o)
self.update_hierarchy_attributes()
for attribute, star in self.hierarchy_attributes: self.update_has_children_for_attribute(attribute, star)
super(HierarchyNode, self).__init__(parent_node)
def _observe(self, x):
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.observe(x, owlready2.observe.CollapsedListener(self._listener2))
else:
observe.observe(x, self._listener)
self.observeds.append(x)
def _unobserve(self, x):
if self.descr.is_owl_entity:
import owlready2.observe
owlready2.observe.unobserve(x, owlready2.observe.CollapsedListener(self._listener2))
else:
observe.unobserve(x, self._listener)
self.observeds.remove(x)
def can_have_children(self): return bool(self.hierarchy_attributes)
def has_children(self): return self.o_has_any_children
def update_hierarchy_attributes(self):
if self.flat_list and self.attribute: self.hierarchy_attributes = []
elif self.restrict_to_attribute:
attribute = self.descr._get_attribute(self.restrict_to_attribute.name)
field_class = attribute.field_class_for(self.o)
self.hierarchy_attributes = [(attribute, field_class.multiple_object_field)]
else:
self.hierarchy_attributes = []
for attribute in self.descr.attributes_of(self.o):
if attribute.name == self.inverse_attr: continue
field_class = attribute.field_class_for(self.o, dont_get_value = True)
if self.hierarchy_pane.pane_repartitor.is_displayed_in_hierarchy_pane(attribute, self.o, field_class):
self.hierarchy_attributes.append((attribute, field_class.multiple_object_field))
def update_has_children_for_attribute(self, attribute, star):
new_has_children = attribute.has_item_for(self.o)
if not new_has_children is self.o_has_children.get(attribute, Inexistent):
if attribute in self.o_has_children:
old_has_children = self.o_has_children[attribute]
if (isinstance(old_has_children, list) or isinstance(old_has_children, set) or isinstance(old_has_children, dict)): self._unobserve(old_has_children)
self.o_has_children[attribute] = new_has_children
if (isinstance(new_has_children, list) or isinstance(new_has_children, set) or isinstance(new_has_children, dict)): self._observe(new_has_children)
if new_has_children: self.o_has_any_children = True
else:
for has_children in self.o_has_children.values():
if has_children: self.o_has_any_children = True; break
else: self.o_has_any_children = False
def update_children_for_attribute(self, attribute, star):
new_o_children = attribute.get_value_for(self.o)
if (new_o_children is None) or (star and (len(new_o_children) == 0)): self.o_has_children[attribute] = False
else: self.o_has_children[attribute] = True
if not new_o_children is self.o_children.get(attribute, Inexistent):
if attribute in self.o_children: self._unobserve(self.o_children[attribute])
self.o_children[attribute] = new_o_children
self._observe(new_o_children)
def create_children(self, old_children = ()):
if not self.o_has_any_children: return []
if self.o_children is None:
self.o_children = {}
for has_children in self.o_has_children.values():
if (isinstance(has_children, list) or isinstance(has_children, set) or isinstance(has_children, dict)): self._unobserve(has_children)
for attribute, star in self.hierarchy_attributes: self.update_children_for_attribute(attribute, star)
old = { (child.attribute, id(child.o)) : child for child in old_children }
children = []
for attribute, star in self.hierarchy_attributes:
if self.o_has_children[attribute]:
if star:
for o in self.o_children[attribute]:
children.append(old.get((attribute, id(o))) or self.__class__(self.hierarchy_pane, self, attribute, o, self.restrict_to_attribute, self.flat_list))
else:
o = self.o_children[attribute]
children.append(old.get((attribute, id(o))) or self.__class__(self.hierarchy_pane, self, attribute, o, self.restrict_to_attribute, self.flat_list))
return children
def _listener(self, o, type, new, old):
self.update()
if (type is list) or (type is set) or (type is dict):
if self.o_children is None:
for attribute, star in self.hierarchy_attributes:
if self.o_has_children[attribute] is o: self.update_has_children_for_attribute(attribute, star)
else:
for attribute, star in self.hierarchy_attributes:
if o is attribute.get_value_for(self.o):
self.update_children_for_attribute(attribute, star)
self.update_children()
elif type is object:
self.update_hierarchy_attributes()
changed_attrs = { attr for attr, new_value, old_value in observe.diffdict(new, old, Inexistent) }
need_update = 0
if self.o_children is None:
for attribute, star in self.hierarchy_attributes:
if attribute.name in changed_attrs: self.update_has_children_for_attribute(attribute, star); need_update = 1
else:
for attribute, star in self.hierarchy_attributes:
if attribute.name in changed_attrs: self.update_children_for_attribute(attribute, star); need_update = 1
if need_update: self.update_children()
elif type == "__class__":
self.descr = introsp.description_for_object(self.o)
self.update_hierarchy_attributes()
if self.o_children is None:
for attribute, star in self.hierarchy_attributes: self.update_has_children_for_attribute(attribute, star)
else:
for attribute, star in self.hierarchy_attributes: self.update_children_for_attribute(attribute, star)
self.update_children()
def _listener2(self, o, diffs):
from owlready2 import IRIS
self.update()
changed_attrs = set()
for attr, new_value, old_value in diffs:
pred = IRIS.get(attr)
if pred: changed_attrs.add(pred.python_name)
else: changed_attrs.add(attr)
changed_attrs.update(attribute.name for attribute in self.descr.property_attributes_of(self.o))
if ("http://www.w3.org/1999/02/22-rdf-syntax-ns#type" in changed_attrs):
self.descr = introsp.description_for_object(self.o)
self.update_hierarchy_attributes()
if self.o_children is None:
for attribute, star in self.hierarchy_attributes: self.update_has_children_for_attribute(attribute, star)
else:
for attribute, star in self.hierarchy_attributes: self.update_children_for_attribute(attribute, star)
self.update_children()
else:
self.descr = introsp.description_for_object(self.o)
self.update_hierarchy_attributes()
need_update = 0
if self.o_children is None:
for attribute, star in self.hierarchy_attributes:
if attribute.name in changed_attrs: self.update_has_children_for_attribute(attribute, star); need_update = 1
else:
for attribute, star in self.hierarchy_attributes:
if attribute.name in changed_attrs: self.update_children_for_attribute(attribute, star); need_update = 1
if need_update: self.update_children()
def destroy(self):
super().destroy()
for i in list(self.observeds): self._unobserve(i)
def node_for_object(self, o):
if self.o is o: return self
for node in self.children:
r = node.node_for_object(o)
if r: return r
def recursive(self):
yield self
for child in self.children: yield from child
def __repr__(self): return "" % self.o
def __str__(self):
if self.attribute and not self.restrict_to_attribute: attr_label = self.attribute.label
else: attr_label = ""
if attr_label: return '''%s: %s''' % (attr_label, self.descr.label_for(self.o))
return self.descr.label_for(self.o)