def _set_object_value(self, row, col, value):
attr = row[-1]
if col == 0:
parse(attr, value)
row[0] = format(attr)
elif col == 1:
attr.isStatic = not attr.isStatic
row[1] = attr.isStatic
elif col == 2:
# Value in attribute object changed:
row[0] = format(attr)
row[1] = attr.isStatic
def format_operation(
el,
pattern=None,
visibility=False,
type=False,
multiplicity=False,
default=False,
tags=False,
direction=False,
):
"""Create a OCL representation of the operation, Returns the operation as a
string."""
name = el.name
if not name:
return ""
if no_render_pat.match(name):
return name
# Render all fields if they all are set to False
if not (visibility or type or multiplicity or default or tags
or direction):
visibility = type = multiplicity = default = tags = direction = True
s = []
if visibility:
s.append(f"{vis_map[el.visibility]} ")
s.append(name)
s.append("(")
for p in el.formalParameter:
s.append(
format(
p,
direction=direction,
type=type,
multiplicity=multiplicity,
default=default,
))
if p is not el.formalParameter[-1]:
s.append(", ")
s.append(")")
rr = el.returnResult and el.returnResult[0]
if rr:
s.append(
format(rr, type=type, multiplicity=multiplicity, default=default))
return "".join(s)
def _set_object_value(self, row, col, value):
operation = row[-1]
if col == 0:
parse(operation, value)
row[0] = format(operation)
elif col == 1:
operation.isAbstract = not operation.isAbstract
row[1] = operation.isAbstract
elif col == 2:
operation.isStatic = not operation.isStatic
row[2] = operation.isStatic
elif col == 3:
row[0] = format(operation)
row[1] = operation.isAbstract
row[2] = operation.isStatic
def _get_rows(self):
for operation in self._item.subject.ownedOperation:
yield [
format(operation),
operation.isAbstract,
operation.isStatic,
operation,
]
def sort_func(model, iter_a, iter_b, userdata):
va = model.get_value(iter_a, 0)
vb = model.get_value(iter_b, 0)
# Put Relationships pseudo-node at top
if va is RELATIONSHIPS:
return -1
if vb is RELATIONSHIPS:
return 1
a = (format(va) or "").lower()
b = (format(vb) or "").lower()
if a == b:
return 0
if a > b:
return 1
return -1
def handler(event):
operation = event.element
for row in self.model:
if row[-1] is operation:
row[:] = [
format(operation),
operation.isAbstract,
operation.isStatic,
operation,
]
def format_property(
el,
visibility=False,
is_derived=False,
type=False,
multiplicity=False,
default=False,
tags=False,
):
"""Create a OCL representation of the attribute, Returns the attribute as a
string. If one or more of the parameters (visibility, is_derived, type,
multiplicity, default and/or tags) is set, only that field is rendered.
Note that the name of the attribute is always rendered, so a parseable
string is returned.
Note that, when some of those parameters are set, parsing the string
will not give you the same result.
"""
name = el.name
if name and no_render_pat.match(name):
return name
# Render all fields if they all are set to False
if not (visibility or is_derived or type or multiplicity or default):
visibility = is_derived = type = multiplicity = default = True
s = []
if name and visibility:
s.append(vis_map[el.visibility])
s.append(" ")
if name and is_derived and el.isDerived:
s.append("/")
if name:
s.append(name)
if type and el.typeValue:
s.append(f": {el.typeValue}")
elif type and el.type and el.type.name:
s.append(f": {el.type.name}")
if multiplicity:
s.append(format_multiplicity(el))
if default and el.defaultValue:
s.append(f" = {el.defaultValue}")
if tags:
slots = [format(slot) for slot in el.appliedStereotype[:].slot if slot]
if slots:
s.append(" { %s }" % ", ".join(slots))
return "".join(s)
def test_interface_with_attributes_and_operation(diagram, element_factory):
iface = element_factory.create(UML.Interface)
attr = element_factory.create(UML.Property)
parse(attr, "- attr: str")
iface.ownedAttribute = attr
oper = element_factory.create(UML.Operation)
parse(oper, "- oper(inout param: str): str")
iface.ownedOperation = oper
iface_item = diagram.create(InterfaceItem, subject=iface)
new_items = copy_clear_and_paste({iface_item}, diagram, element_factory)
new_iface_item = new_items.pop()
assert isinstance(new_iface_item, InterfaceItem)
assert format(new_iface_item.subject.ownedAttribute[0]) == "- attr: str"
assert (format(new_iface_item.subject.ownedOperation[0]) ==
"- oper(inout param: str): str")
def association_item_inline_editor(item, view, pos=None) -> bool:
"""Text edit support for Named items."""
@transactional
def update_text(text):
item.subject.name = text
return True
@transactional
def update_end_text(text):
assert end_item
parse(end_item.subject, text)
return True
subject = item.subject
if not subject:
return False
end_item = None
if pos and distance_point_point_fast(item.handles()[0].pos, pos) < 50:
end_item = item.head_end
elif pos and distance_point_point_fast(item.handles()[-1].pos, pos) < 50:
end_item = item.tail_end
if end_item:
text = (format(
end_item.subject,
visibility=True,
is_derived=True,
type=True,
multiplicity=True,
default=True,
) or "")
def escape():
assert end_item
parse(end_item.subject, text)
entry = popup_entry(text, update_end_text)
bb = end_item.name_bounds
x, y = view.get_matrix_i2v(item).transform_point(bb.x, bb.y)
box = Rectangle(x, y, 10, 10)
else:
text = item.subject.name or ""
def escape():
item.subject.name = text
entry = popup_entry(text, update_text)
box = editable_text_box(view, view.hovered_item)
show_popover(entry, view, box, escape)
return True
def update_end_name(self, builder, end_name, subject):
name = builder.get_object(f"{end_name}-name")
new_name = (format(
subject,
visibility=True,
is_derived=True,
multiplicity=True,
) or "")
if not (name.is_focus() or self.semaphore):
self.semaphore += 1
name.set_text(new_name)
self.semaphore -= 1
return name
def test_class_with_attributes(diagram, element_factory):
cls = element_factory.create(UML.Class)
attr = element_factory.create(UML.Property)
parse(attr, "- attr: str")
cls.ownedAttribute = attr
cls_item = diagram.create(ClassItem, subject=cls)
new_items = copy_clear_and_paste({cls_item}, diagram, element_factory)
new_cls_item = new_items.pop()
assert isinstance(new_cls_item, ClassItem)
assert format(new_cls_item.subject.ownedAttribute[0]) == "- attr: str"
def test_class_with_operation(diagram, element_factory):
cls = element_factory.create(UML.Class)
oper = element_factory.create(UML.Operation)
parse(oper, "- oper(inout param: str): str")
cls.ownedOperation = oper
cls_item = diagram.create(ClassItem, subject=cls)
new_items = copy_clear_and_paste({cls_item}, diagram, element_factory)
new_cls_item = new_items.pop()
assert isinstance(new_cls_item, ClassItem)
assert (format(new_cls_item.subject.ownedOperation[0]) ==
"- oper(inout param: str): str")
def format_association_end(el) -> Tuple[str, str]:
"""Format association end."""
name = ""
n = []
if el.name:
n.append(vis_map[el.visibility])
n.append(" ")
if el.isDerived:
n.append("/")
n.append(el.name)
name = "".join(n)
m = [format_multiplicity(el, bare=True)]
slots = [format(slot) for slot in el.appliedStereotype[:].slot if slot]
if slots:
m.append(" { %s }" % ",\n".join(slots))
mult = "".join(m)
return name, mult
def search_func(model, column, key, rowiter):
# Note that this function returns `False` for a match!
assert column == 0
row = model[rowiter]
matched = False
# Search in child rows. If any element in the underlying
# tree matches, it will expand.
for inner in row.iterchildren():
if not search_func(model, column, key, inner.iter):
view.expand_to_path(row.path)
matched = True
element = list(row)[column]
s = format(element)
if s and key.lower() in s.lower():
matched = True
elif not matched:
view.collapse_row(row.path)
return not matched # False means match found!
def _set_text(self, column, cell, model, iter, data):
"""Set font and of model elements in tree view."""
element = model.get_value(iter, 0)
cell.set_property(
"weight",
Pango.Weight.BOLD
if isinstance(element, Diagram) else Pango.Weight.NORMAL,
)
cell.set_property(
"style",
Pango.Style.ITALIC
if isinstance(element, (UML.Classifier, UML.BehavioralFeature))
and element.isAbstract else Pango.Style.NORMAL,
)
if element is RELATIONSHIPS:
text = gettext("<Relationships>")
else:
text = format(element) or "<None>"
cell.set_property("text", text)
def lazy_format(slot):
return lambda: format(slot)
def lazy_format(attribute):
return lambda: format(attribute)
def lazy_format(operation):
return lambda: format(operation,
visibility=True,
type=True,
multiplicity=True,
default=True)
def _get_rows(self):
for attr in self._item.subject.ownedAttribute:
if not attr.association:
yield [format(attr), attr.isStatic, attr]
def handler(event):
attribute = event.element
for row in self.model:
if row[-1] is attribute:
row[:] = [format(attribute), attribute.isStatic, attribute]
