def construct(self):
if not self.item.subject:
return
builder = new_builder("operations-editor")
show_operations = builder.get_object("show-operations")
show_operations.set_active(self.item.show_operations)
self.model = ClassOperations(self.item, (str, bool, bool, object))
tree_view: Gtk.TreeView = builder.get_object("operations-list")
tree_view.set_model(self.model)
def handler(event):
operation = event.element
for row in self.model:
if row[-1] is operation:
row[:] = [
UML.format(operation),
operation.isAbstract,
operation.isStatic,
operation,
]
self.watcher.watch("ownedOperation.name", handler).watch(
"ownedOperation.isAbstract", handler
).watch("ownedOperation.visibility", handler).watch(
"ownedOperation.returnResult.lowerValue", handler
).watch(
"ownedOperation.returnResult.upperValue", handler
).watch(
"ownedOperation.returnResult.typeValue", handler
).watch(
"ownedOperation.formalParameter.lowerValue", handler
).watch(
"ownedOperation.formalParameter.upperValue", handler
).watch(
"ownedOperation.formalParameter.typeValue", handler
).watch(
"ownedOperation.formalParameter.defaultValue", handler
).subscribe_all()
builder.connect_signals(
{
"show-operations-changed": (self._on_show_operations_change,),
"operations-name-edited": (on_text_cell_edited, self.model, 0),
"operations-abstract-edited": (on_bool_cell_edited, self.model, 1),
"operations-static-edited": (on_bool_cell_edited, self.model, 2),
"tree-view-destroy": (self.watcher.unsubscribe_all,),
"operations-keypress": (on_keypress_event,),
}
)
return builder.get_object("operations-editor")
def construct(self):
if not self.subject:
return None
builder = new_builder("association-editor")
head = self.item.head_end
tail = self.item.tail_end
show_direction = builder.get_object("show-direction")
show_direction.set_active(self.item.show_direction)
head_signal_handlers = self.construct_end(builder, "head", head)
tail_signal_handlers = self.construct_end(builder, "tail", tail)
def name_handler(event):
end_name = "head" if event.element is head.subject else "tail"
self.update_end_name(builder, end_name, event.element)
def restore_nav_handler(event):
prop = event.element
if prop.type and prop.opposite and prop.opposite.type:
for end_name, end in (("head", head), ("tail", tail)):
combo = builder.get_object(f"{end_name}-navigation")
self._on_end_navigability_change(combo, end)
# Watch on association end:
self.watcher.watch("memberEnd[Property].name", name_handler).watch(
"memberEnd[Property].visibility", name_handler).watch(
"memberEnd[Property].lowerValue",
name_handler).watch("memberEnd[Property].upperValue",
name_handler).watch(
"memberEnd[Property].type",
restore_nav_handler,
)
builder.connect_signals({
"show-direction-changed": (self._on_show_direction_change, ),
"invert-direction-changed": (self._on_invert_direction_change, ),
"head-name-changed": (self._on_end_name_change, head),
"head-navigation-changed":
(self._on_end_navigability_change, head),
"head-aggregation-changed":
(self._on_end_aggregation_change, head),
"tail-name-changed": (self._on_end_name_change, tail),
"tail-navigation-changed":
(self._on_end_navigability_change, tail),
"tail-aggregation-changed":
(self._on_end_aggregation_change, tail),
"association-editor-destroy": (self.watcher.unsubscribe_all, ),
**head_signal_handlers,
**tail_signal_handlers,
})
return builder.get_object("association-editor")
def construct(self):
if UML.model.is_metaclass(self.subject):
return
builder = new_builder("classifier-editor")
abstract = builder.get_object("abstract")
abstract.set_active(self.subject.isAbstract)
builder.connect_signals({"abstract-changed": (self._on_abstract_change,)})
return builder.get_object("classifier-editor")
def construct(self):
subject = self.subject
if not subject:
return
builder = new_builder("join-node-editor")
join_spec = builder.get_object("join-spec")
join_spec.set_text(subject.joinSpec or "")
builder.connect_signals({"join-spec-changed": (self._on_join_spec_change,)})
return builder.get_object("join-node-editor")
def construct(self):
subject = self.subject
if not subject:
return
builder = new_builder("component-editor")
ii = builder.get_object("indirectly-instantiated")
ii.set_active(subject.isIndirectlyInstantiated)
builder.connect_signals(
{"indirectly-instantiated-changed": (self._on_ii_change, )})
return builder.get_object("component-editor")
def construct(self):
item = self.item
if item.toplevel:
return
builder = new_builder("partition-editor")
external = builder.get_object("external")
external.set_active(item.subject.isExternal)
builder.connect_signals(
{"external-changed": (self._on_external_change, )})
return builder.get_object("partition-editor")
def construct(self):
builder = new_builder("interface-editor")
item = self.item
connected_items = [c.item for c in item.canvas.get_connections(connected=item)]
disallowed = (ConnectorItem,)
can_fold = not any(map(lambda i: isinstance(i, disallowed), connected_items))
folded = builder.get_object("folded")
folded.set_active(item.folded != Folded.NONE)
folded.set_sensitive(can_fold)
builder.connect_signals({"folded-changed": (self._on_fold_change,)})
return builder.get_object("interface-editor")
def construct(self):
if not self.item.subject:
return
builder = new_builder("attributes-editor")
page = builder.get_object("attributes-editor")
show_attributes = builder.get_object("show-attributes")
show_attributes.set_active(self.item.show_attributes)
self.model = ClassAttributes(self.item, (str, bool, object))
tree_view: Gtk.TreeView = builder.get_object("attributes-list")
tree_view.set_model(self.model)
def handler(event):
attribute = event.element
for row in self.model:
if row[-1] is attribute:
row[:] = [UML.format(attribute), attribute.isStatic, attribute]
self.watcher.watch("ownedAttribute.name", handler).watch(
"ownedAttribute.isDerived", handler
).watch("ownedAttribute.visibility", handler).watch(
"ownedAttribute.isStatic", handler
).watch(
"ownedAttribute.lowerValue", handler
).watch(
"ownedAttribute.upperValue", handler
).watch(
"ownedAttribute.defaultValue", handler
).watch(
"ownedAttribute.typeValue", handler
).subscribe_all()
builder.connect_signals(
{
"show-attributes-changed": (self._on_show_attributes_change,),
"attributes-name-edited": (on_text_cell_edited, self.model, 0),
"attributes-static-edited": (on_bool_cell_edited, self.model, 1),
"tree-view-destroy": (self.watcher.unsubscribe_all,),
"attributes-keypress": (on_keypress_event,),
}
)
return page
def construct(self):
subject = self.item.subject
if not subject:
return None
stereotypes = UML.model.get_stereotypes(subject)
if not stereotypes:
return None
builder = new_builder("stereotypes-editor")
show_stereotypes = builder.get_object("show-stereotypes")
if hasattr(self.item, "show_stereotypes"):
show_stereotypes.set_active(self.item.show_stereotypes)
else:
show_stereotypes.destroy()
self.model = Gtk.TreeStore.new(
[
str, # stereotype/attribute
str, # value
bool, # is applied stereotype
bool, # show checkbox (is stereotype)
bool, # value editable
object, # stereotype / attribute
object, # value editable
object, # slot element
]
)
stereotype_list = builder.get_object("stereotype-list")
stereotype_list.set_model(self.model)
builder.connect_signals(
{
"show-stereotypes-changed": (self._on_show_stereotypes_change,),
"toggle-stereotype": (self._toggle_stereotype, self.model, 2),
"set-slot-value": (self._set_value, self.model, 1),
}
)
self.refresh()
return builder.get_object("stereotypes-editor")
def construct(self):
if not self.subject:
return None
builder = new_builder("association-editor")
head = self.item.head_end
tail = self.item.tail_end
show_direction = builder.get_object("show-direction")
show_direction.set_active(self.item.show_direction)
self.construct_end(builder, "head", head)
self.construct_end(builder, "tail", tail)
def handler(event):
end_name = "head" if event.element is head.subject else "tail"
self.update_end_name(builder, end_name, event.element)
# Watch on association end:
self.watcher.watch("memberEnd[Property].name", handler).watch(
"memberEnd[Property].aggregation",
handler).watch("memberEnd[Property].visibility", handler).watch(
"memberEnd[Property].lowerValue",
handler).watch("memberEnd[Property].upperValue",
handler).subscribe_all()
builder.connect_signals({
"show-direction-changed": (self._on_show_direction_change, ),
"invert-direction-changed": (self._on_invert_direction_change, ),
"head-name-changed": (self._on_end_name_change, head),
"head-navigation-changed":
(self._on_end_navigability_change, head),
"head-aggregation-changed":
(self._on_end_aggregation_change, head),
"tail-name-changed": (self._on_end_name_change, tail),
"tail-navigation-changed":
(self._on_end_navigability_change, tail),
"tail-aggregation-changed":
(self._on_end_aggregation_change, tail),
"association-editor-destroy": (self.watcher.unsubscribe_all, ),
})
return builder.get_object("association-editor")
def construct(self):
subject = self.subject
if not subject:
return
builder = new_builder("transition-editor")
guard = builder.get_object("guard")
guard.set_text(subject.guard or "")
def handler(event):
v = event.new_value
guard.set_text(v or "")
self.watcher.watch("guard", handler)
builder.connect_signals({
"guard-changed": (self._on_guard_change, ),
"transition-destroy": (self.watcher.unsubscribe_all, ),
})
return builder.get_object("transition-editor")
def construct(self):
subject = self.subject
if not subject:
return
builder = new_builder("transition-editor")
guard = builder.get_object("guard")
if subject.guard:
guard.set_text(subject.guard.specification or "")
def handler(event):
if event.element is subject.guard:
guard.set_text(event.new_value or "")
self.watcher.watch("guard[Constraint].specification", handler)
builder.connect_signals({
"guard-changed": (self._on_guard_change, ),
"transition-destroy": (self.watcher.unsubscribe_all, ),
})
return builder.get_object("transition-editor")
def construct(self):
"""Creates the Partition Property Page."""
builder = new_builder("partition-editor")
num_partitions = builder.get_object("num-partitions")
adjustment = Gtk.Adjustment(
value=len(self.item.partition),
lower=1,
upper=10,
step_increment=1,
page_increment=5,
)
num_partitions.set_adjustment(adjustment)
builder.connect_signals(
{"partitions-changed": (self._on_num_partitions_changed,)}
)
treeview = builder.get_object("partition-treeview")
treeview.set_model(self.list_store)
renderer_text = Gtk.CellRendererText()
column_text = Gtk.TreeViewColumn(title="#", cell_renderer=renderer_text, text=0)
treeview.append_column(column_text)
renderer_editable_text = Gtk.CellRendererText()
renderer_editable_text.set_property("editable", True)
column_editabletext = Gtk.TreeViewColumn(
title="Name", cell_renderer=renderer_editable_text, text=1
)
treeview.append_column(column_editabletext)
renderer_editable_text.connect("edited", self._on_partition_name_changed)
self.update_list_store()
return builder.get_object("partition-editor")
def construct(self):
subject = self.item.subject
if not subject:
return
builder = new_builder("object-node-editor")
upper_bound = builder.get_object("upper-bound")
upper_bound.set_text(subject.upperBound or "")
ordering = builder.get_object("ordering")
ordering.set_active(self.ORDERING_VALUES.index(subject.ordering))
show_ordering = builder.get_object("show-ordering")
show_ordering.set_active(self.item.show_ordering)
builder.connect_signals({
"upper-bound-changed": (self._on_upper_bound_change, ),
"ordering-changed": (self._on_ordering_change, ),
"show-ordering-changed": (self._on_ordering_show_change, ),
})
return builder.get_object("object-node-editor")
def __init__(self, item):
super().__init__()
self.item = item
self.watcher = self.item.watcher()
self.builder = new_builder("dependency-editor")
