class PortsTab(Tab,
HasCommonSetup,
SubscribesToEvents,
Resetable):
"""Used to create, edit and remove components.
Attributes:
__selected_port: Currently selected port in the ports listview.
__selected_component: Currently selected component in the components taxonomy view.
"""
def __init__(self, parent_notebook):
self.__state = State()
self.__selected_port: Optional[Port] = None
self.__selected_component: Optional[Component] = None
Tab.__init__(self, parent_notebook, TAB_NAME)
HasCommonSetup.__init__(self)
SubscribesToEvents.__init__(self)
# HasCommonSetup
def _create_widgets(self) -> None:
self.__taxonomy_tree = ScrollbarListbox(self,
on_select_callback=self.__on_select_tree_item,
heading=TREEVIEW_HEADING,
extract_id=lambda x: x.id_,
extract_text=lambda x: x.name,
extract_ancestor=lambda x: '' if x.parent_id is None else x.parent_id,
extract_values=self.__extract_values,
columns=[Column('Amount')],
values=self.__state.model.taxonomy)
self.__left_frame = ttk.Frame(self)
# Ports combobox
self.__port_combobox_var = tk.StringVar(value=SELECT_PORT)
self.__port_combobox_var.trace('w', self.__on_combobox_changed)
# state='readonly' means you cannot write freely in the combobox
self.__port_combobox = ttk.Combobox(self.__left_frame, state='readonly',
textvariable=self.__port_combobox_var, font=FONT)
ports_names = self.__state.model.get_all_ports_names()
self.__port_combobox['values'] = sorted(ports_names)
# C(r)ud Buttons
self.__add_port_button = ttk.Button(self.__left_frame, text='Add', state=tk.NORMAL,
command=self.__on_add)
self.__rename_port_button = ttk.Button(self.__left_frame, text='Rename', state=tk.DISABLED,
command=self.__on_rename)
self.__remove_port_button = ttk.Button(self.__left_frame, text='Remove', state=tk.DISABLED,
command=self.__remove)
# Force connection
self.__force_connection_checkbox_var = tk.BooleanVar(value=False)
self.__force_connection_checkbox_var.trace('w', self.__on_force_connection_toggled)
self.__force_connection_checkbox_label = ttk.Label(self.__left_frame,
text='Force connection:')
self.__force_connection_checkbox = ttk.Checkbutton(self.__left_frame, state=tk.DISABLED,
variable=self.__force_connection_checkbox_var)
# Force connection checkbox
self.__compatible_with_edit_button = ttk.Button(self.__left_frame, text='Edit compatibility',
command=self.__on_edit_compatible_with, state=tk.DISABLED)
self.__compatible_with_listbox = ScrollbarListbox(self.__left_frame,
extract_text=lambda prt: prt.name,
extract_id=lambda prt: prt.id_,
columns=[Column('Compatible with', main=True, stretch=tk.YES)])
self.__cmp_label_var = tk.StringVar(value='')
self.__cmp_label = ttk.Label(self.__left_frame, textvariable=self.__cmp_label_var, style='Big.TLabel', anchor=tk.CENTER)
self.__amount_spinbox_label = ttk.Label(self.__left_frame, text='Has:')
self.__amount_spinbox_var = tk.IntVar(value='')
self.__amount_spinbox_var.trace('w', self.__on_amount_changed)
self.__amount_spinbox = ttk.Spinbox(self.__left_frame, from_=0, to=math.inf,
textvariable=self.__amount_spinbox_var)
self.__all_children_amount_spinbox_label = ttk.Label(self.__left_frame, text='Children have:')
self.__all_children_amount_spinbox_var = tk.IntVar(value='')
self.__all_children_amount_spinbox = ttk.Spinbox(self.__left_frame, from_=0, to=math.inf,
textvariable=self.__all_children_amount_spinbox_var)
self.__apply_to_all_children_button = ttk.Button(self.__left_frame, text='Apply to all children',
command=self.__apply_to_all_children)
def _setup_layout(self) -> None:
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW)
self.__left_frame.grid(row=0, column=0, sticky=tk.NSEW, pady=FRAME_PAD_Y, padx=FRAME_PAD_X)
self.__port_combobox.grid(row=0, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__add_port_button.grid(row=1, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__rename_port_button.grid(row=2, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__remove_port_button.grid(row=3, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__force_connection_checkbox_label.grid(row=4, column=0, sticky=tk.W, pady=CONTROL_PAD_Y)
self.__force_connection_checkbox.grid(row=4, column=1, sticky=tk.E, pady=CONTROL_PAD_Y)
self.__compatible_with_edit_button.grid(row=5, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__compatible_with_listbox.grid(row=6, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__cmp_label.grid(row=7, column=0, columnspan=2, pady=CONTROL_PAD_Y, sticky=tk.EW)
self.__amount_spinbox_label.grid(row=8, column=0, pady=CONTROL_PAD_Y, sticky=tk.W)
self.__amount_spinbox.grid(row=8, column=1, pady=CONTROL_PAD_Y, sticky=tk.NSEW)
self.__all_children_amount_spinbox_label.grid(row=8, column=0, pady=CONTROL_PAD_Y, sticky=tk.W)
self.__all_children_amount_spinbox.grid(row=8, column=1, pady=CONTROL_PAD_Y, sticky=tk.NSEW)
self.__apply_to_all_children_button.grid(row=9, column=0, columnspan=2, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.columnconfigure(1, weight=1) # Give all the remaining space to taxonomy tree
self.rowconfigure(0, weight=1)
self.__left_frame.columnconfigure(1, weight=1)
# Hide widgets
self.__taxonomy_tree.grid_forget()
self.__cmp_label.grid_forget()
self.__amount_spinbox_label.grid_forget()
self.__amount_spinbox.grid_forget()
self.__all_children_amount_spinbox_label.grid_forget()
self.__all_children_amount_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
# Taxonomy Treeview
def __on_select_tree_item(self, cmp_id: int) -> None:
"""Executed whenever a tree item is selected (by mouse click).
:param cmp_id: Id of the selected component.
"""
if self.__selected_port:
selected_cmp = self.__state.model.get_component(id_=cmp_id)
self.__selected_component = selected_cmp
self.__cmp_label.grid(row=7, column=0, columnspan=2, pady=CONTROL_PAD_Y, sticky=tk.EW) # Show cmp label
self.__cmp_label_var.set(trim_string(selected_cmp.name, length=30)) # Fill the label with component name
if selected_cmp.is_leaf:
self.__all_children_amount_spinbox_label.grid_forget() # Hide widgets (changing all children)
self.__all_children_amount_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
self.__all_children_amount_spinbox_var.set(0)
amount = 0
if self.__selected_port.id_ in selected_cmp.ports:
amount = selected_cmp.ports[self.__selected_port.id_]
self.__amount_spinbox_var.set(amount)
self.__amount_spinbox_label.grid(row=8, column=0, pady=CONTROL_PAD_Y, sticky=tk.W) # Show widgets for leaves
self.__amount_spinbox.grid(row=8, column=1, pady=CONTROL_PAD_Y, sticky=tk.NSEW)
else:
self.__amount_spinbox_label.grid_forget() # Hide widgets for leaves
self.__amount_spinbox.grid_forget()
self.__all_children_amount_spinbox_label.grid(row=8, column=0, pady=CONTROL_PAD_Y, sticky=tk.W) # Show widgets (changing all children)
self.__all_children_amount_spinbox.grid(row=8, column=1, pady=CONTROL_PAD_Y, sticky=tk.NSEW)
self.__apply_to_all_children_button.grid(row=9, column=0, columnspan=2, sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
def __extract_values(self, cmp: Component) -> Tuple[Any, ...]:
"""Extracts the data of the component to show in the taxonomy view.
:param cmp: Component from which to extract the data.
:return: Tuple containing data about component
(number of ports the of type __selected_port that the component has,).
"""
amount = ''
if self.__selected_port:
if self.__selected_port.id_ in cmp.ports:
amount = cmp.ports[self.__selected_port.id_]
return amount,
def __build_tree(self) -> None:
"""Fills the tree view with components from model."""
self.__taxonomy_tree.set_items(self.__state.model.taxonomy)
def __on_combobox_changed(self, *_) -> None:
"""Executed whenever the __port_combobox value changes."""
# Hide component-specific widgets
self.__cmp_label.grid_forget()
self.__amount_spinbox_label.grid_forget()
self.__amount_spinbox.grid_forget()
self.__all_children_amount_spinbox_label.grid_forget()
self.__all_children_amount_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
prt_name = self.__port_combobox_var.get()
port = self.__state.model.get_port(name=prt_name)
buttons_to_change_state_of = [
self.__rename_port_button,
self.__remove_port_button,
self.__force_connection_checkbox,
self.__compatible_with_edit_button,
]
if port:
self.__selected_port = port
change_controls_state(tk.NORMAL, *buttons_to_change_state_of)
compatible_ports = self.__state.model.get_ports_by_ids(port.compatible_with)
self.__compatible_with_listbox.set_items(compatible_ports) # Fill the 'compatible with' listbox
self.__force_connection_checkbox_var.set(port.force_connection)
self.__update_tree() # Update tree values
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW) # Show tree
else:
self.__selected_port = None
self.__force_connection_checkbox_var.set(False)
self.__compatible_with_listbox.set_items([]) # Clear 'compatible with' listbox
change_controls_state(tk.DISABLED,
*buttons_to_change_state_of)
self.__taxonomy_tree.grid_forget() # Hide tree
def __update_tree(self) -> None:
"""Updates every leaf component in the taxonomy treeview."""
leaf_cmps = self.__state.model.get_components(is_leaf=True)
self.__taxonomy_tree.update_values(*leaf_cmps)
# SubscribesToListeners
def _subscribe_to_events(self) -> None:
pub.subscribe(self.__on_model_loaded, actions.MODEL_LOADED)
pub.subscribe(self.__on_taxonomy_edited, actions.TAXONOMY_EDITED)
pub.subscribe(self._reset, actions.RESET)
def __on_taxonomy_edited(self):
"""Executed whenever the structure of the taxonomy changes."""
self.__build_tree()
self.__selected_component = None
self.__cmp_label_var.set('')
self.__cmp_label.grid_forget()
self.__amount_spinbox_label.grid_forget()
self.__amount_spinbox.grid_forget()
self.__all_children_amount_spinbox_label.grid_forget()
self.__all_children_amount_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
def __on_model_loaded(self):
"""Executed whenever a model is loaded from file."""
self._reset()
self.__build_tree()
ports_names = self.__state.model.get_all_ports_names()
self.__port_combobox['values'] = sorted(ports_names)
# Resetable
def _reset(self) -> None:
self.__selected_port = None
self.__selected_component = None
self.__taxonomy_tree.set_items([])
self.__port_combobox_var.set(SELECT_PORT)
self.__port_combobox['values'] = []
self.__taxonomy_tree.grid_forget() # Hide treeview
# Class-specific
# Ports
def __on_add(self) -> None:
"""Executed whenever the __add_port_button is pressed."""
AskStringWindow(self, self.__add, 'Add port', 'Enter name of a new port.')
def __add(self, name: str) -> None:
"""Executed after creating of a new port.
:param name: Name of a new port.
"""
prt = Port(name)
self.__state.model.add_port(prt)
self.__selected_port = prt
self.__port_combobox['values'] = sorted(self.__state.model.get_all_ports_names())
self.__port_combobox_var.set(prt.name)
change_controls_state(tk.NORMAL,
self.__rename_port_button,
self.__remove_port_button,
self.__force_connection_checkbox,
self.__compatible_with_edit_button)
def __on_rename(self) -> None:
"""Executed whenever the __rename_port_button is pressed."""
if self.__selected_port:
AskStringWindow(self, self.__rename, 'Rename port',
f'Enter new name for "{self.__selected_port.name}" port.',
string=self.__selected_port.name)
def __rename(self, new_name: str) -> None:
"""Executed after renaming of a port.
:param new_name: New name for the __selected_port.
"""
prt = self.__state.model.rename_port(self.__selected_port, new_name)
self.__port_combobox['values'] = sorted(self.__state.model.get_all_ports_names())
self.__port_combobox_var.set(prt.name)
def __remove(self) -> None:
"""Executed whenever the __remove_port_button is pressed.
Removes __selected_port from model.
"""
if self.__selected_port:
removed_prt = self.__state.model.remove_port(self.__selected_port)
updated_combobox_values = [val for val in [*self.__port_combobox['values']] if val != removed_prt.name]
self.__port_combobox['values'] = updated_combobox_values
self.__selected_port = None
self.__port_combobox_var.set(SELECT_PORT)
self.__compatible_with_listbox.set_items([]) # Clear the compatible with
change_controls_state(tk.DISABLED,
self.__rename_port_button,
self.__remove_port_button,
self.__force_connection_checkbox,
self.__compatible_with_edit_button)
# Hide component-specific widgets
self.__cmp_label.grid_forget()
self.__amount_spinbox_label.grid_forget()
self.__amount_spinbox.grid_forget()
self.__all_children_amount_spinbox_label.grid_forget()
self.__all_children_amount_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
self.__update_tree()
def __on_edit_compatible_with(self):
"""Executed whenever the __compatible_with_edit_button is pressed."""
if self.__selected_port:
all_ports = self.__state.model.ports
compatible_ports = [p for p in all_ports if p.id_ in self.__selected_port.compatible_with]
ports_rest = [p for p in all_ports if p not in compatible_ports and p.id_ != self.__selected_port.id_]
SelectPortsWindow(self, self.__selected_port, compatible_ports, ports_rest,
callback=self.__edit_compatible_with)
def __edit_compatible_with(self, ports: List[Port]) -> None:
"""Executed after editing the list of ports compatible with __selected_port.
:param ports: New list of ports compatible with __selected_port.
"""
if self.__selected_port:
ports.sort(key=lambda x: x.name)
self.__compatible_with_listbox.set_items(ports)
self.__state.model.update_ports_compatibility(self.__selected_port, ports)
def __on_force_connection_toggled(self, *_):
"""Executed whenever the __force_connection_checkbox is toggled."""
if self.__selected_port:
value = self.__force_connection_checkbox_var.get()
self.__selected_port.force_connection = value
def __on_amount_changed(self, *_):
"""Executed whenever the __amount_spinbox value changes."""
if self.__selected_component and self.__selected_port:
value = None
try:
value = self.__amount_spinbox_var.get()
except tk.TclError:
pass
finally:
if value:
self.__selected_component.ports[self.__selected_port.id_] = value
elif self.__selected_port.id_ in self.__selected_component.ports:
del self.__selected_component.ports[self.__selected_port.id_]
self.__taxonomy_tree.update_values(self.__selected_component)
def __apply_to_all_children(self):
"""Executed whenever the __apply_to_all_children_button is pressed."""
if self.__selected_component and self.__selected_port:
value = None
try:
value = self.__all_children_amount_spinbox_var.get()
except tk.TclError:
pass
finally:
updated_components = self.__state.model.set_ports_amount_to_all_components_children(
self.__selected_component, self.__selected_port, value)
self.__taxonomy_tree.update_values(*updated_components)
class InstancesTab(Tab,
HasCommonSetup,
SubscribesToEvents,
Resetable):
"""Used to set the number of instances of components.
Attributes:
__selected_component: Currently selected component in the components taxonomy view.
"""
def __init__(self,
parent_notebook: ttk.Notebook):
self.__state = State()
self.__selected_component: Optional[Component] = None
Tab.__init__(self, parent_notebook, TAB_NAME)
HasCommonSetup.__init__(self)
SubscribesToEvents.__init__(self)
# HasCommonSetup
def _create_widgets(self):
self.__taxonomy_tree = ScrollbarListbox(self,
on_select_callback=self.__on_select_tree_item,
heading=TREEVIEW_HEADING,
extract_id=lambda x: x.id_,
extract_text=lambda x: x.name,
extract_ancestor=lambda x: '' if x.parent_id is None else x.parent_id,
extract_values=self.__extract_values,
columns=[Column('Count'),
Column('Min'),
Column('Max'),
Column('Symmetry breaking?')],
values=self.__state.model.taxonomy)
self.__left_frame = ttk.Frame(self)
self.__global_symmetry_breaking_frame = ttk.Frame(self.__left_frame)
self.__global_symmetry_breaking_checkbox_label = ttk.Label(self.__global_symmetry_breaking_frame,
text='Symmetry breaking\n'
'for all components:')
self.__global_symmetry_breaking_checkbox_var = tk.BooleanVar(value=False)
self.__global_symmetry_breaking_checkbox = ttk.Checkbutton(self.__global_symmetry_breaking_frame,
variable=self.__global_symmetry_breaking_checkbox_var)
self.__apply_global_symmetry_breaking_button = ttk.Button(self.__global_symmetry_breaking_frame, text='Apply',
command=self.__apply_symmetry_breaking_for_all_components)
self.__component_separator = ttk.Separator(self.__left_frame, orient=tk.HORIZONTAL)
self.__cmp_label_var = tk.StringVar(value='')
self.__cmp_label = ttk.Label(self.__left_frame, textvariable=self.__cmp_label_var, style='Big.TLabel',
anchor=tk.CENTER)
self.__symm_breaking_checkbox_var = tk.BooleanVar(value=False)
self.__symm_breaking_checkbox_var.trace('w', self.__on_symmetry_breaking_toggled)
self.__symm_breaking_checkbox_label = ttk.Label(self.__left_frame, text='Symmetry\nbreaking:')
self.__symm_breaking_checkbox = ttk.Checkbutton(self.__left_frame, variable=self.__symm_breaking_checkbox_var)
self.__exact_value_radiobutton_var = tk.BooleanVar(value=True)
self.__exact_value_radiobutton_var.trace('w', self.__on_exact_value_radiobutton_changed)
self.__exact_value_radiobutton = ttk.Radiobutton(self.__left_frame, value=True, text='Exact', state=tk.DISABLED,
variable=self.__exact_value_radiobutton_var)
self.__range_radiobutton = ttk.Radiobutton(self.__left_frame, text='Range', value=False, state=tk.DISABLED,
variable=self.__exact_value_radiobutton_var)
self.__exact_minimum_spinbox_label_var = tk.StringVar(value=EXACT_COUNT_LABEL_TEXT)
self.__exact_minimum_spinbox_label = ttk.Label(self.__left_frame,
textvariable=self.__exact_minimum_spinbox_label_var)
self.__exact_minimum_spinbox_var = tk.IntVar(value='')
self.__exact_minimum_spinbox_var.trace('w', self.__on_count_changed)
self.__exact_minimum_spinbox = ttk.Spinbox(self.__left_frame, from_=0, to=math.inf, state=tk.DISABLED,
textvariable=self.__exact_minimum_spinbox_var)
self.__max_spinbox_label = ttk.Label(self.__left_frame, text='Max:')
self.__max_spinbox_var = tk.IntVar()
self.__max_spinbox_var.trace('w', self.__on_max_changed)
self.__max_spinbox = ttk.Spinbox(self.__left_frame, from_=1, to=math.inf,
textvariable=self.__max_spinbox_var)
self.__apply_symmetry_breaking_to_all_children_button = ttk.Button(self.__left_frame,
text='Apply to children',
command=self.__apply_symmetry_breaking_to_all_children,
style='SmallFont.TButton')
self.__apply_count_to_all_children_button = ttk.Button(self.__left_frame, text='Apply to all children',
command=self.__apply_count_to_all_children)
def _setup_layout(self):
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW)
self.__left_frame.grid(row=0, column=0, sticky=tk.NSEW, padx=FRAME_PAD_X, pady=FRAME_PAD_Y)
self.__global_symmetry_breaking_frame.grid(row=0, column=0, columnspan=4, sticky=tk.NSEW)
self.__global_symmetry_breaking_frame.columnconfigure(0, weight=1)
self.__global_symmetry_breaking_frame.columnconfigure(1, weight=1)
self.__global_symmetry_breaking_frame.columnconfigure(2, weight=1)
self.__global_symmetry_breaking_checkbox_label.grid(row=0, column=0, sticky=tk.W, pady=CONTROL_PAD_Y, padx=CONTROL_PAD_X)
self.__global_symmetry_breaking_checkbox.grid(row=0, column=1, sticky=tk.W, pady=CONTROL_PAD_Y, padx=CONTROL_PAD_X)
self.__apply_global_symmetry_breaking_button.grid(row=0, column=2, sticky=tk.EW, pady=CONTROL_PAD_Y, padx=CONTROL_PAD_X)
self.__component_separator.grid(row=1, column=0, columnspan=4, sticky=tk.EW, pady=CONTROL_PAD_Y, padx=CONTROL_PAD_X)
self.__cmp_label.grid(row=2, column=0, columnspan=4, sticky=tk.EW, pady=CONTROL_PAD_Y)
self.__symm_breaking_checkbox_label.grid(row=3, column=0, sticky=tk.W, pady=CONTROL_PAD_Y, padx=CONTROL_PAD_X)
self.__symm_breaking_checkbox.grid(row=3, column=1, sticky=tk.NW, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__apply_symmetry_breaking_to_all_children_button.grid(row=3, column=2, columnspan=2, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__exact_value_radiobutton.grid(row=4, column=0, sticky=tk.W, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__range_radiobutton.grid(row=4, column=1, sticky=tk.W, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__exact_minimum_spinbox_label.grid(row=5, column=0, sticky=tk.W, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__exact_minimum_spinbox.grid(row=5, column=1, sticky=tk.EW, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__max_spinbox_label.grid(row=5, column=2, sticky=tk.W, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__max_spinbox.grid(row=5, column=3, sticky=tk.EW, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__apply_count_to_all_children_button.grid(row=6, column=0, columnspan=4, sticky=tk.NSEW, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
# Hide 'for all children' widgets
self.__apply_symmetry_breaking_to_all_children_button.grid_forget()
self.__max_spinbox_label.grid_forget()
self.__max_spinbox.grid_forget()
self.__apply_count_to_all_children_button.grid_forget()
self.__left_frame.columnconfigure(0, weight=1, uniform='fred')
self.__left_frame.columnconfigure(1, weight=1, uniform='fred')
self.__left_frame.columnconfigure(2, weight=1, uniform='fred')
self.__left_frame.columnconfigure(3, weight=1, uniform='fred')
self.columnconfigure(0, weight=1, uniform='fred')
self.columnconfigure(1, weight=3, uniform='fred')
self.rowconfigure(0, weight=1)
# SubscribesToListeners
def _subscribe_to_events(self):
pub.subscribe(self.__on_model_loaded, actions.MODEL_LOADED)
pub.subscribe(self.__build_tree, actions.TAXONOMY_EDITED)
pub.subscribe(self._reset, actions.RESET)
@staticmethod
def __extract_values(cmp: Component) -> Tuple[Any, ...]:
"""Extracts the data of the component to show in the taxonomy view.
:param cmp: Component from which to extract the data.
:return: Tuple containing data about component
(exact count, min_count, max_count, apply symmetry breaking?).
"""
return (cmp.count if cmp.count else '',
cmp.min_count if cmp.min_count is not None else '',
cmp.max_count if cmp.max_count is not None else '',
BOOLEAN_TO_STRING_DICT[cmp.symmetry_breaking])
def __on_model_loaded(self) -> None:
"""Executed whenever a model is loaded from file."""
self.__build_tree()
def __build_tree(self) -> None:
"""Fills the tree view with components from model."""
self.__taxonomy_tree.set_items(self.__state.model.taxonomy)
# Taxonomy Treeview
def __on_select_tree_item(self, cmp_id: int) -> None:
"""Executed whenever a tree item is selected (by mouse click).
:param cmp_id: Id of the selected component.
"""
selected_cmp: Component = self.__state.model.get_component(id_=cmp_id)
self.__selected_component = selected_cmp
self.__cmp_label_var.set(trim_string(selected_cmp.name, length=LABEL_LENGTH))
radiobutton_val = selected_cmp.exact if selected_cmp.exact is not None else True
self.__exact_value_radiobutton_var.set(radiobutton_val)
# Enable symmetry breaking checkbox & spinbox
change_controls_state(tk.NORMAL,
self.__exact_minimum_spinbox,
self.__symm_breaking_checkbox,
self.__range_radiobutton,
self.__exact_value_radiobutton,
self.__exact_minimum_spinbox)
if selected_cmp.is_leaf:
# Set the spinbox values
if selected_cmp.exact:
set_spinbox_var_value(self.__exact_minimum_spinbox_var, selected_cmp.count)
else:
set_spinbox_var_value(self.__exact_minimum_spinbox_var, selected_cmp.min_count)
set_spinbox_var_value(self.__max_spinbox_var, selected_cmp.max_count)
self.__symm_breaking_checkbox_var.set(selected_cmp.symmetry_breaking)
self.__apply_symmetry_breaking_to_all_children_button.grid_forget()
self.__apply_count_to_all_children_button.grid_forget()
else:
# Show apply to all children
self.__apply_symmetry_breaking_to_all_children_button.grid(row=3, column=2, columnspan=2, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__apply_count_to_all_children_button.grid(row=6, column=0, columnspan=4, sticky=tk.NSEW, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
# Reset symmetry breaking for all components
self.__symm_breaking_checkbox_var.set(False)
# Resetable
def _reset(self) -> None:
self.__selected_component = None
# Disable widgets
change_controls_state(tk.DISABLED,
self.__exact_minimum_spinbox,
self.__symm_breaking_checkbox,
self.__range_radiobutton,
self.__exact_value_radiobutton,
self.__exact_minimum_spinbox)
# Hide 'for all children' widgets
self.__apply_symmetry_breaking_to_all_children_button.grid_forget()
self.__max_spinbox_label.grid_forget()
self.__max_spinbox.grid_forget()
self.__apply_count_to_all_children_button.grid_forget()
# Set entries to default
self.__exact_minimum_spinbox_var.set('')
self.__max_spinbox_var.set('')
self.__cmp_label_var.set('')
self.__symm_breaking_checkbox_var.set(False)
self.__global_symmetry_breaking_checkbox_var.set(False)
# Clear the tree
self.__taxonomy_tree.set_items([])
def __on_symmetry_breaking_toggled(self, *_) -> None:
"""Executed whenever the __symmetry_breaking_checkbox is toggled"""
if self.__selected_component and self.__selected_component.is_leaf:
self.__selected_component.symmetry_breaking = self.__symm_breaking_checkbox_var.get()
self.__taxonomy_tree.update_values(self.__selected_component)
def __on_count_changed(self, *_) -> None:
"""Executed whenever the __exact_minimum_spinbox value changes."""
if self.__selected_component:
exact = self.__exact_value_radiobutton_var.get()
try:
value = self.__exact_minimum_spinbox_var.get()
if exact:
if self.__selected_component.is_leaf:
self.__selected_component.count = value
# Reset min/max counter
self.__selected_component.min_count = None
self.__selected_component.max_count = None
else:
max_value = self.__max_spinbox_var.get()
if self.__selected_component.is_leaf:
self.__selected_component.min_count = value
# Reset count property
self.__selected_component.count = None
if value >= max_value:
new_max_value = value + 1
self.__max_spinbox_var.set(new_max_value)
if self.__selected_component.is_leaf:
self.__selected_component.max_count = new_max_value
except tk.TclError:
self.__selected_component.count = None # Reset both
self.__selected_component.min_count = None
finally:
self.__taxonomy_tree.update_values(self.__selected_component)
def __apply_count_to_all_children(self) -> None:
"""Executed whenever the __apply_count_to_all_children_button is pressed."""
if self.__selected_component:
exact = self.__exact_value_radiobutton_var.get()
if exact:
count = None
try:
count = self.__exact_minimum_spinbox_var.get()
except tk.TclError:
pass
finally:
updated_cmps = self.__state.model.set_components_leaf_children_properties(self.__selected_component,
exact=True, count=count,
min_count=None,
max_count=None)
else:
min_count = None
max_count = None
try:
min_count = self.__exact_minimum_spinbox_var.get()
max_count = self.__max_spinbox_var.get()
except tk.TclError:
pass
finally:
updated_cmps = self.__state.model.set_components_leaf_children_properties(self.__selected_component,
exact=False,
count=None,
min_count=min_count,
max_count=max_count)
self.__taxonomy_tree.update_values(*updated_cmps)
def __apply_symmetry_breaking_to_all_children(self):
"""Executed whenever the __apply_symmetry_breaking_to_all_children_button is pressed."""
if self.__selected_component:
symm_breaking = True
try:
symm_breaking = self.__symm_breaking_checkbox_var.get()
except tk.TclError:
pass
finally:
updated_cmps = self.__state.model.set_components_leaf_children_properties(self.__selected_component,
symmetry_breaking=symm_breaking)
self.__taxonomy_tree.update_values(*updated_cmps)
def __on_exact_value_radiobutton_changed(self, *_):
"""Executed whenever the __exact_value_radiobutton's value changes."""
if self.__selected_component:
self.__exact_minimum_spinbox_var.set(0)
self.__max_spinbox_var.set(0)
self.__selected_component.count = None
self.__selected_component.min_count = None
self.__selected_component.max_count = None
exact_value = self.__exact_value_radiobutton_var.get()
if exact_value:
self.__max_spinbox_label.grid_forget() # Hide 'Max' label and spinbox
self.__max_spinbox.grid_forget()
self.__exact_minimum_spinbox_label_var.set(EXACT_COUNT_LABEL_TEXT)
else:
# Restore max widgets
self.__max_spinbox_label.grid(row=5, column=2, sticky=tk.W, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__max_spinbox.grid(row=5, column=3, sticky=tk.EW, padx=CONTROL_PAD_X, pady=CONTROL_PAD_Y)
self.__exact_minimum_spinbox_label_var.set(MIN_COUNT_LABEL_TEXT)
if self.__selected_component.is_leaf:
self.__selected_component.exact = exact_value
self.__taxonomy_tree.update_values(self.__selected_component)
def __on_max_changed(self, *_):
"""Executed whenever the __max_spinbox value changes."""
if self.__selected_component:
try:
max_value = self.__max_spinbox_var.get()
if self.__selected_component.is_leaf:
self.__selected_component.max_count = max_value
min_value = self.__exact_minimum_spinbox_var.get()
if max_value <= min_value and max_value >= 1:
new_min_value = max_value - 1
self.__exact_minimum_spinbox_var.set(new_min_value)
if self.__selected_component.is_leaf:
self.__selected_component.min_count = new_min_value
except tk.TclError:
pass
finally:
self.__taxonomy_tree.update_values(self.__selected_component)
def __apply_symmetry_breaking_for_all_components(self):
"""Executed whenever the __apply_global_symmetry_breaking_button is pressed."""
if self.__taxonomy_tree:
symm_breaking = self.__global_symmetry_breaking_checkbox_var.get()
updated_cmps = self.__state.model.set_all_leaf_components_properties(symmetry_breaking=symm_breaking)
self.__taxonomy_tree.update_values(*updated_cmps)
class TaxonomyTab(Tab, HasCommonSetup, SubscribesToEvents, Resetable):
"""Used to create, edit and remove components.
Attributes:
__selected_component: Currently selected component in the components taxonomy view.
"""
def __init__(self, parent_notebook):
self.__state: State = State()
self.__selected_component: Optional[Component] = None
Tab.__init__(self, parent_notebook, TAB_NAME)
HasCommonSetup.__init__(self)
SubscribesToEvents.__init__(self)
# HasCommonSetup
def _create_widgets(self):
self.__taxonomy_tree = ScrollbarListbox(
self,
on_select_callback=self.__on_select_tree_item,
heading=TREEVIEW_HEADING,
extract_id=lambda x: x.id_,
extract_text=lambda x: x.name,
extract_ancestor=lambda x: ''
if x.parent_id is None else x.parent_id,
values=self.__state.model.taxonomy,
)
self.__right_frame = ttk.Frame(self)
self.__cmp_name_var = tk.StringVar()
self.__cmp_name_var.set('')
self.__cmp_name_label = ttk.Label(self.__right_frame,
anchor=tk.CENTER,
textvariable=self.__cmp_name_var,
style='Big.TLabel')
self.__rename_button = ttk.Button(self.__right_frame,
text='Rename',
command=self.__on_rename,
state=tk.DISABLED)
self.__add_sibling_button = ttk.Button(self.__right_frame,
text='Add sibling',
command=self.__on_add_sibling)
self.__add_child_button = ttk.Button(self.__right_frame,
text='Add child',
command=self.__on_add_child)
self.__remove_button = ttk.Button(self.__right_frame,
text='Remove',
command=self.__remove,
state=tk.DISABLED)
self.__remove_recursively_button = ttk.Button(
self.__right_frame,
text='Remove recursively',
state=tk.DISABLED,
command=lambda: self.__remove(recursively=True))
self.__create_taxonomy_button = ttk.Button(
self,
text="Create taxonomy",
command=self.__on_create_taxonomy,
width=14)
def _setup_layout(self):
self.__taxonomy_tree.grid(row=0, column=0, sticky=tk.NSEW)
self.__right_frame.grid(row=0,
column=1,
sticky=tk.NSEW,
pady=FRAME_PAD_Y,
padx=FRAME_PAD_X)
self.__cmp_name_label.grid(row=0, sticky=tk.EW, pady=CONTROL_PAD_Y)
self.__rename_button.grid(row=1, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__add_sibling_button.grid(row=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__add_child_button.grid(row=3, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__remove_button.grid(row=4, sticky=tk.NSEW, pady=CONTROL_PAD_Y)
self.__remove_recursively_button.grid(row=5,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__create_taxonomy_button.grid(row=1, column=0, padx=30, pady=5)
# Hide widgets
self.rowconfigure(0, weight=1)
self.columnconfigure(1, weight=1, uniform='fred')
self.columnconfigure(0, weight=3, uniform='fred')
self.__right_frame.columnconfigure(0, weight=1)
# SubscribesToListeners
def _subscribe_to_events(self):
pub.subscribe(self.__on_model_loaded, actions.MODEL_LOADED)
pub.subscribe(self._reset, actions.RESET)
# Taxonomy Treeview
def __on_select_tree_item(self, cmp_id: int) -> None:
"""Executed whenever a tree item is selected (by mouse click).
:param cmp_id: Id of the selected component.
"""
selected_cmp: Component = self.__state.model.get_component(id_=cmp_id)
self.__selected_component = selected_cmp
self.__cmp_name_var.set(trim_string(selected_cmp.name, length=22))
change_controls_state(tk.NORMAL, self.__remove_button,
self.__remove_recursively_button,
self.__rename_button)
def __on_model_loaded(self):
"""Executed whenever a model is loaded from file."""
self._reset()
self.__build_tree()
def __build_tree(self) -> None:
"""Fills the tree view with components from model."""
self.__taxonomy_tree.set_items(self.__state.model.taxonomy)
# Resetable
def _reset(self) -> None:
self.__taxonomy_tree.set_items([])
self.__selected_component = None
self.__cmp_name_var.set('')
change_controls_state(tk.DISABLED, self.__remove_button,
self.__remove_recursively_button,
self.__rename_button)
# Class-specific
def __add(self, cmp_name: str, level: int,
parent_id: Optional[int]) -> None:
"""Executed after creating of a new component.
:param cmp_name: Name of a new component
:param level: Level of the new component.
:param parent_id: Id of the parent of the new component.
"""
cmp = Component(cmp_name,
level,
parent_id=parent_id,
is_leaf=True,
symmetry_breaking=True)
self.__state.model.add_component(cmp)
self.__taxonomy_tree.add_item(cmp)
self.__selected_component = cmp
self.__cmp_name_var.set(trim_string(cmp.name, length=22))
change_controls_state(tk.NORMAL, self.__remove_button,
self.__remove_recursively_button,
self.__rename_button)
pub.sendMessage(actions.TAXONOMY_EDITED)
def __on_add_sibling(self) -> None:
"""Executed whenever the __add_sibling_button is pressed."""
sibling_name = BASE_COMPONENT_NAME if self.__selected_component is None else self.__selected_component.name
level = 0 if self.__selected_component is None else self.__selected_component.level
parent_id = None if self.__selected_component is None else self.__selected_component.parent_id
AskStringWindow(
self, lambda cmp_name: self.__add(cmp_name, level, parent_id),
'Add sibling',
f'Enter name of sibling of the {sibling_name} component.')
def __on_add_child(self) -> None:
"""Executed whenever the __add_child_button is pressed."""
sibling_name = BASE_COMPONENT_NAME if self.__selected_component is None else self.__selected_component.name
level = 0 if self.__selected_component is None else self.__selected_component.level + 1
parent_id = None if self.__selected_component is None else self.__selected_component.id_
AskStringWindow(
self, lambda cmp_name: self.__add(cmp_name, level, parent_id),
'Add sibling',
f'Enter name of child of the {sibling_name} component.')
def __rename(self, new_name: str) -> None:
"""Executed after renaming __selected_component.
:param new_name: New name of the component.
"""
cmp = self.__state.model.rename_component(self.__selected_component,
new_name)
self.__cmp_name_var.set(trim_string(cmp.name, length=22))
self.__taxonomy_tree.rename_item(self.__selected_component)
pub.sendMessage(actions.TAXONOMY_EDITED)
def __on_rename(self) -> None:
"""Executed whenever the __rename_button is pressed."""
if self.__selected_component:
AskStringWindow(
self,
self.__rename,
'Rename component',
f'Enter new name for "{self.__selected_component.name}" component.',
string=self.__selected_component.name)
def __remove(self, recursively=False) -> None:
"""Executed whenever the __rename_button or __remove_recursively_button is pressed.
:param recursively: True if __remove_recursively_button is pressed. Removes the selected component and all of
its children; Otherwise set to False and removes only the __selected_component, setting the
parent_id of its children to __selected_component.parent_id.
"""
if self.__selected_component:
if recursively:
_, removed_ctrs = self.__state.model.remove_component_recursively(
self.__selected_component)
self.__taxonomy_tree.remove_item_recursively(
self.__selected_component)
else:
_, removed_ctrs = self.__state.model.remove_component_preserve_children(
self.__selected_component)
self.__taxonomy_tree.remove_item_preserve_children(
self.__selected_component)
# Prompt about removing the constraints
if removed_ctrs:
removed_ctrs_names_list_string = f' {PUNCTUATOR_SYMBOL} '
removed_ctrs_names_list_string += f"\n {PUNCTUATOR_SYMBOL} ".join(
[ctr.name for ctr in removed_ctrs])
messagebox.showwarning(
message=f'Removed component was present in constraints.'
f'\nThe following constraints were thus removed:'
f'\n{removed_ctrs_names_list_string}',
parent=self)
# Disable constrols
change_controls_state(tk.DISABLED, self.__remove_button,
self.__remove_recursively_button,
self.__rename_button)
self.__selected_component = None
self.__cmp_name_var.set('')
pub.sendMessage(actions.TAXONOMY_EDITED)
def __create_taxonomy(self):
"""Executes when the taxonomy is created (in the CreateTaxonomyWindow)."""
self.__build_tree()
pub.sendMessage(actions.TAXONOMY_EDITED)
def __on_create_taxonomy(self) -> None:
"""Executed whenever the __create_taxonomy_button is pressed."""
if self.__state.model.taxonomy:
answer = messagebox.askyesno(
'Create taxonomy',
'Warning: taxonomy has already been created.\n'
'If you use this option again, previous taxonomy will be '
"overwritten, and you will lose all constraints' data and "
"possibly ports, resources, instances, associations"
'instances etc.\nIf you plan to make simple changes, use '
'options such as "Create sibling", "Create child", etc. '
'on the right tab.',
icon=tk.messagebox.WARNING,
parent=self)
if not answer:
return
CreateTaxonomyWindow(self, self.__create_taxonomy)
class ConstraintsTab(Tab, HasCommonSetup, SubscribesToEvents, Resetable):
"""Used to create, edit and remove constraints.
Attributes:
__selected_constraint: Currently selected constraint in the constraints list view.
"""
def __init__(self, parent_notebook):
self.__state = State()
self.__selected_constraint: Optional[
Any] = None # can be either simple or complex constraint
Tab.__init__(self, parent_notebook, TAB_NAME)
HasCommonSetup.__init__(self)
SubscribesToEvents.__init__(self)
# HasCommonSetup
def _create_widgets(self) -> None:
self.__constraints_listbox = ScrollbarListbox(
self,
columns=[Column('Type')],
heading='Constraint',
extract_id=lambda crt: crt.id_,
extract_text=lambda crt: crt.name,
extract_values=lambda crt: 'Simple'
if isinstance(crt, SimpleConstraint) else 'Complex',
on_select_callback=self.__on_select_callback,
values=self.__state.model.get_all_constraints())
self.__right_frame = ttk.Frame(self)
# Ctr label
self.__ctr_label_var = tk.StringVar(value='')
self.__ctr_label = ttk.Label(self.__right_frame,
textvariable=self.__ctr_label_var,
style='Big.TLabel',
anchor=tk.CENTER)
self.__add_simple_constraint_button = ttk.Button(
self.__right_frame,
text='Add simple constraint',
command=self.__on_add)
self.__add_complex_constraint_button = ttk.Button(
self.__right_frame,
text='Add complex constraint',
command=lambda: self.__on_add(complex_=True))
self.__edit_constraint_button = ttk.Button(self.__right_frame,
text='Edit',
state=tk.DISABLED,
command=self.__on_edit)
self.__remove_constraint_button = ttk.Button(
self.__right_frame,
text='Remove',
state=tk.DISABLED,
command=self.__remove_constraint)
def _setup_layout(self) -> None:
self.__constraints_listbox.grid(row=0, column=0, sticky=tk.NSEW)
self.__right_frame.grid(row=0,
column=1,
sticky=tk.NSEW,
pady=FRAME_PAD_Y,
padx=FRAME_PAD_X)
self.__ctr_label.grid(row=0,
column=0,
pady=CONTROL_PAD_Y,
sticky=tk.EW)
self.__add_simple_constraint_button.grid(row=1,
column=0,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__add_complex_constraint_button.grid(row=2,
column=0,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__edit_constraint_button.grid(row=3,
column=0,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__remove_constraint_button.grid(row=4,
column=0,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.columnconfigure(0, weight=1)
self.rowconfigure(0, weight=1)
# SubscribesToEvents
def _subscribe_to_events(self) -> None:
pub.subscribe(self.__on_model_changed, actions.MODEL_LOADED)
pub.subscribe(self.__on_model_changed, actions.TAXONOMY_EDITED)
pub.subscribe(self._reset, actions.RESET)
# Resetable
def _reset(self) -> None:
self.__constraints_listbox.set_items([])
self.__selected_constraint = None
self.__ctr_label_var.set('')
change_controls_state(tk.DISABLED, self.__edit_constraint_button,
self.__remove_constraint_button)
def __on_select_callback(self, ctr_id: int):
"""Executed whenever a constraints listview item is selected (by mouse click).
:param ctr_id: Id of the selected constraint.
"""
selected_ctr = self.__state.model.get_constraint(id_=ctr_id)
if selected_ctr:
self.__selected_constraint = selected_ctr
self.__ctr_label_var.set(
trim_string(selected_ctr.name, length=LABEL_LENGTH))
# Enable buttons
change_controls_state(tk.NORMAL, self.__edit_constraint_button,
self.__remove_constraint_button)
def __add(self, ctr: Any) -> None:
"""Executed after adding a new constraint in SimpleConstraintWindow or ComplexConstraintWindow.
:param ctr: New SimpleConstraint or ComplexConstraint obtained from SimpleConstraintWindow
or ComplexConstraintWindow.
"""
_, index = self.__state.model.add_constraint(ctr)
self.__constraints_listbox.add_item(ctr, index=index)
# Set selected constraint to the newly created constraint
self.__selected_constraint = ctr
self.__ctr_label_var.set(trim_string(ctr.name, length=LABEL_LENGTH))
# Enable buttons
change_controls_state(tk.NORMAL, self.__edit_constraint_button,
self.__remove_constraint_button)
def __edit(self, ctr: Any):
"""Executed after editing the constraint in SimpleConstraintWindow or ComplexConstraintWindow.
:param ctr: Edited SimpleConstraint or ComplexConstraint obtained from SimpleConstraintWindow
or ComplexConstraintWindow.
"""
_, index = self.__state.model.edit_constraint(ctr)
self.__selected_constraint = ctr
# Just in case if the name has changed
self.__constraints_listbox.rename_item(
ctr, index=index) # Update constraint name in treeview
self.__ctr_label_var.set(trim_string(
ctr.name, length=LABEL_LENGTH)) # Update constraint label
def __on_add(self, complex_=False):
"""Executed whenever the __add_simple_constraint_button or __add_complex_constraint_button are pressed.
:param complex_: If __add_complex_constraint_button is pressed then set to True; False otherwise.
"""
if complex_:
ComplexConstraintWindow(self, callback=self.__add)
else:
SimpleConstraintWindow(self, callback=self.__add)
def __on_edit(self):
"""Executed whenever the __edit_constraint_button is pressed."""
if self.__selected_constraint:
if isinstance(self.__selected_constraint, SimpleConstraint):
SimpleConstraintWindow(self,
constraint=self.__selected_constraint,
callback=self.__edit)
else:
ComplexConstraintWindow(self,
constraint=self.__selected_constraint,
callback=self.__edit)
def __remove_constraint(self):
"""Executed whenever the __remove_constraint_button is pressed.
Removes selected constraint from model.
"""
if self.__selected_constraint:
self.__state.model.remove_constraint(self.__selected_constraint)
self.__constraints_listbox.remove_item_recursively(
self.__selected_constraint)
self.__selected_constraint = None
# Hide widgets
self.__ctr_label_var.set('')
change_controls_state(tk.DISABLED, self.__edit_constraint_button,
self.__remove_constraint_button)
def __on_model_changed(self):
"""Executed whenever a model is loaded from file or taxonomy changes."""
ctrs = self.__state.model.get_all_constraints()
self.__constraints_listbox.set_items(ctrs)
self.__selected_constraint = None
self.__ctr_label_var.set('')
change_controls_state(tk.DISABLED, self.__edit_constraint_button,
self.__remove_constraint_button)
class ResourcesTab(Tab, HasCommonSetup, SubscribesToEvents, Resetable):
"""Used to create, edit and remove components.
Attributes:
__selected_resource: Currently selected resource in the resources listview.
__selected_component: Currently selected component in the components taxonomy view.
"""
def __init__(self, parent_notebook):
self.__state = State()
self.__selected_resource: Optional[Resource] = None
self.__selected_component: Optional[Component] = None
Tab.__init__(self, parent_notebook, TAB_NAME)
HasCommonSetup.__init__(self)
SubscribesToEvents.__init__(self)
# HasCommonSetup
def _create_widgets(self):
self.__taxonomy_tree = ScrollbarListbox(
self,
on_select_callback=self.__on_select_tree_item,
heading=TREEVIEW_HEADING,
extract_id=lambda x: x.id_,
extract_text=lambda x: x.name,
extract_ancestor=lambda x: ''
if x.parent_id is None else x.parent_id,
extract_values=self.__extract_values,
columns=[Column('Produces')],
values=self.__state.model.taxonomy)
self.__left_frame = ttk.Frame(self)
# Resources combobox
self.__resource_combobox_var = tk.StringVar(value=SELECT_RESOURCE)
self.__resource_combobox_var.trace('w', self.__on_combobox_changed)
self.__resource_combobox = ttk.Combobox(
self.__left_frame,
state='readonly',
font=FONT,
textvariable=self.__resource_combobox_var)
# Fill the Combobox
resources_names = self.__state.model.get_all_resources_names()
self.__resource_combobox['values'] = sorted(resources_names)
self.__resource_combobox_var.set(SELECT_RESOURCE)
# C(r)ud Buttons
self.__add_resource_button = ttk.Button(self.__left_frame,
text='Add',
state=tk.NORMAL,
command=self.__on_add)
self.__rename_resource_button = ttk.Button(self.__left_frame,
text='Rename',
state=tk.DISABLED,
command=self.__on_rename)
self.__remove_resource_button = ttk.Button(self.__left_frame,
text='Remove',
state=tk.DISABLED,
command=self.__remove)
# Cmp label
self.__cmp_label_var = tk.StringVar(value='')
self.__cmp_label = ttk.Label(self.__left_frame,
textvariable=self.__cmp_label_var,
style='Big.TLabel',
anchor=tk.CENTER)
self.__produces_spinbox_label = ttk.Label(self.__left_frame,
text='Produces:')
self.__produces_spinbox_var = tk.IntVar(value='')
self.__produces_spinbox_var.trace('w', self.__on_produced_changed)
self.__produces_spinbox = ttk.Spinbox(
self.__left_frame,
from_=-math.inf,
to=math.inf,
textvariable=self.__produces_spinbox_var)
self.__all_children_produce_spinbox_label = ttk.Label(
self.__left_frame, text='Produces:')
self.__all_children_produce_spinbox_var = tk.IntVar(value=0)
self.__all_children_produce_spinbox = ttk.Spinbox(
self.__left_frame,
from_=-math.inf,
to=math.inf,
textvariable=self.__all_children_produce_spinbox_var)
self.__apply_to_all_children_button = ttk.Button(
self.__left_frame,
text='Apply to all children',
command=self.__apply_to_all_children)
def _setup_layout(self):
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW)
self.__left_frame.grid(row=0,
column=0,
sticky=tk.NSEW,
pady=FRAME_PAD_Y,
padx=FRAME_PAD_X)
self.__resource_combobox.grid(row=0,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__add_resource_button.grid(row=1,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__rename_resource_button.grid(row=2,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__remove_resource_button.grid(row=3,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__cmp_label.grid(row=4,
column=0,
columnspan=2,
pady=CONTROL_PAD_Y,
sticky=tk.EW)
self.__produces_spinbox_label.grid(row=5,
column=0,
pady=CONTROL_PAD_Y,
sticky=tk.W)
self.__produces_spinbox.grid(row=5,
column=1,
pady=CONTROL_PAD_Y,
sticky=tk.NSEW)
self.__all_children_produce_spinbox_label.grid(row=5,
column=0,
pady=CONTROL_PAD_Y,
sticky=tk.W)
self.__all_children_produce_spinbox.grid(row=5,
column=1,
pady=CONTROL_PAD_Y,
sticky=tk.NSEW)
self.__apply_to_all_children_button.grid(row=6,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.columnconfigure(0, weight=1, uniform='fred')
self.columnconfigure(1, weight=3, uniform='fred')
self.rowconfigure(0, weight=1)
self.__left_frame.columnconfigure(1, weight=1)
# Hide widgets
self.__taxonomy_tree.grid_forget()
self.__cmp_label.grid_forget()
self.__produces_spinbox_label.grid_forget()
self.__produces_spinbox.grid_forget()
self.__all_children_produce_spinbox_label.grid_forget()
self.__all_children_produce_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
# SubscribesToListeners
def _subscribe_to_events(self):
pub.subscribe(self.__on_model_loaded, actions.MODEL_LOADED)
pub.subscribe(self.__on_taxonomy_edited, actions.TAXONOMY_EDITED)
pub.subscribe(self._reset, actions.RESET)
# HasTaxonomyTree
def __on_select_tree_item(self, cmp_id: int) -> None:
"""Executed whenever a tree item is selected (by mouse click).
:param cmp_id: Id of the selected component.
"""
if self.__selected_resource:
selected_cmp: Component = self.__state.model.get_component(
id_=cmp_id)
self.__selected_component = selected_cmp
self.__cmp_label.grid(row=4,
column=0,
columnspan=2,
pady=CONTROL_PAD_Y,
sticky=tk.EW)
self.__cmp_label_var.set(trim_string(selected_cmp.name, length=23))
if selected_cmp.is_leaf:
self.__all_children_produce_spinbox_label.grid_forget(
) # Hide widgets (changing all children)
self.__all_children_produce_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
produced = 0
if self.__selected_resource.id_ in selected_cmp.produces:
produced = selected_cmp.produces[
self.__selected_resource.id_]
self.__produces_spinbox_var.set(produced)
self.__produces_spinbox_label.grid(row=5,
column=0,
pady=CONTROL_PAD_Y,
sticky=tk.W)
self.__produces_spinbox.grid(row=5,
column=1,
pady=CONTROL_PAD_Y,
sticky=tk.NSEW)
else:
self.__produces_spinbox_label.grid_forget(
) # Hide widgets for leaves
self.__produces_spinbox.grid_forget()
# Show widgets (changing all children)
self.__all_children_produce_spinbox_var.set(0)
self.__all_children_produce_spinbox_label.grid(
row=5, column=0, pady=CONTROL_PAD_Y, sticky=tk.W)
self.__all_children_produce_spinbox.grid(row=5,
column=1,
pady=CONTROL_PAD_Y,
sticky=tk.NSEW)
self.__apply_to_all_children_button.grid(row=6,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
def __extract_values(self, cmp: Component) -> Tuple[Any, ...]:
"""Extracts the data of the component to show in the taxonomy view.
:param cmp: Component from which to extract the data.
:return: Tuple containing data about component
(amount of produced resource of type __selected_resource,).
"""
produces = ''
if self.__selected_resource:
if self.__selected_resource.id_ in cmp.produces:
produces = cmp.produces[self.__selected_resource.id_]
return produces, # Coma means 1-element tuple
def __build_tree(self) -> None:
"""Fills the tree view with components from model."""
self.__taxonomy_tree.set_items(self.__state.model.taxonomy)
def __on_model_loaded(self):
"""Executed whenever a model is loaded from file."""
self._reset()
self.__build_tree()
resources_names = self.__state.model.get_all_resources_names()
self.__resource_combobox['values'] = sorted(resources_names)
self.__resource_combobox_var.set(SELECT_RESOURCE)
def __on_taxonomy_edited(self) -> None:
"""Executed whenever the structure of the taxonomy changes."""
self._reset()
self.__build_tree()
# Resetable
def _reset(self) -> None:
self.__selected_component = None
self.__selected_resource = None
# Hide widgets
self.__produces_spinbox_label.grid_forget()
self.__produces_spinbox.grid_forget()
self.__all_children_produce_spinbox_label.grid_forget()
self.__all_children_produce_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
# Set entries to default
self.__resource_combobox['values'] = ()
self.__resource_combobox_var.set(SELECT_RESOURCE)
self.__produces_spinbox_var.set('')
self.__all_children_produce_spinbox_var.set('')
self.__cmp_label_var.set('')
# Disable buttons
change_controls_state(tk.DISABLED, self.__rename_resource_button,
self.__remove_resource_button)
self.__taxonomy_tree.set_items([])
self.__taxonomy_tree.grid_forget()
# Class-specific
def __on_combobox_changed(self, *_):
"""Executed whenever the __resource_combobox value changes."""
res_name = self.__resource_combobox_var.get()
resource = self.__state.model.get_resource(name=res_name)
if resource:
# Enable buttons
change_controls_state(tk.NORMAL, self.__rename_resource_button,
self.__remove_resource_button)
self.__selected_resource = resource
if self.__selected_component:
if self.__selected_component.is_leaf:
produced = 0
if resource.id_ in self.__selected_component.produces:
produced = self.__selected_component.produces[
self.__selected_resource.id_]
self.__produces_spinbox_var.set(produced)
else:
self.__all_children_produce_spinbox_var.set('')
# Show the taxonomy tree
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW)
self.__update_tree()
def __update_tree(self):
"""Updates every leaf component in the taxonomy treeview."""
leaf_cmps = self.__state.model.get_components(is_leaf=True)
self.__taxonomy_tree.update_values(*leaf_cmps)
def __on_add(self):
"""Executed whenever the __add_resource_button is pressed."""
AskStringWindow(self, self.__add, 'Add resource',
'Enter name of a new resource.')
def __add(self, name: str):
"""Executed after creating of a new resource.
:param name: Name of a new resource.
"""
res = Resource(name)
self.__state.model.add_resource(res)
self.__selected_resource = res
self.__resource_combobox['values'] = sorted(
self.__state.model.get_all_resources_names())
self.__resource_combobox_var.set(res.name)
# Enable buttons
change_controls_state(tk.NORMAL, self.__rename_resource_button,
self.__remove_resource_button)
# Show the taxonomy tree
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW)
self.__update_tree()
def __on_rename(self) -> None:
"""Executed whenever the __rename_resource_button is pressed."""
if self.__selected_resource:
AskStringWindow(
self,
self.__rename,
'Rename resource',
f'Enter new name for "{self.__selected_resource.name}" resource.',
string=self.__selected_resource.name)
def __rename(self, new_name: str) -> None:
"""Executed after renaming of a resource.
:param new_name: New name for the __selected_resource.
"""
res = self.__state.model.rename_resource(self.__selected_resource,
new_name)
self.__resource_combobox['values'] = sorted(
self.__state.model.get_all_resources_names())
self.__resource_combobox_var.set(res.name)
def __remove(self):
"""Executed whenever the __remove_resource_button is pressed.
Removes __selected_resource from model.
"""
if self.__selected_resource:
self.__state.model.remove_resource(self.__selected_resource)
self.__resource_combobox['values'] = sorted(
self.__state.model.get_all_resources_names())
self.__selected_resource = None
self.__resource_combobox_var.set(SELECT_RESOURCE)
# Disable buttons
change_controls_state(tk.DISABLED, self.__rename_resource_button,
self.__remove_resource_button)
# Hide widgets
self.__cmp_label.grid_forget()
self.__produces_spinbox_label.grid_forget()
self.__produces_spinbox.grid_forget()
self.__all_children_produce_spinbox_label.grid_forget()
self.__all_children_produce_spinbox.grid_forget()
self.__apply_to_all_children_button.grid_forget()
# Hide the taxonomy tree
self.__taxonomy_tree.grid_forget()
def __on_produced_changed(self, *_):
"""Executed whenever the __produces_spinbox value changes."""
if self.__selected_component and self.__selected_resource:
value = None
try:
value = self.__produces_spinbox_var.get()
except tk.TclError:
pass
finally:
if value:
self.__selected_component.produces[
self.__selected_resource.id_] = value
elif self.__selected_resource.id_ in self.__selected_component.produces:
del self.__selected_component.produces[
self.__selected_resource.id_]
self.__taxonomy_tree.update_values(self.__selected_component)
def __apply_to_all_children(self):
"""Executed whenever the __apply_to_all_children_button is pressed."""
if self.__selected_component and self.__selected_resource:
value = None
try:
value = self.__all_children_produce_spinbox_var.get()
except tk.TclError:
pass
finally:
updated_components = self.__state.model.set_resource_production_to_all_components_children(
self.__selected_component, self.__selected_resource, value)
self.__taxonomy_tree.update_values(*updated_components)
class AssociationsTab(Tab, HasCommonSetup, SubscribesToEvents, Resetable):
"""Used to set the number of information about the associations between the root component and other components.
Attributes:
__selected_component: Currently selected component in the components taxonomy view.
"""
def __init__(self, parent_notebook):
self.__state = State()
self.__selected_component: Optional[Component] = None
Tab.__init__(self, parent_notebook, TAB_NAME)
HasCommonSetup.__init__(self)
SubscribesToEvents.__init__(self)
# HasCommonSetup
def _create_widgets(self):
self.__taxonomy_tree = ScrollbarListbox(
self,
on_select_callback=self.__on_select_tree_item,
heading=TREEVIEW_HEADING,
extract_id=lambda x: x.id_,
extract_text=lambda x: x.name,
extract_ancestor=lambda x: ''
if x.parent_id is None else x.parent_id,
extract_values=self.__extract_values,
values=self.__state.model.taxonomy,
columns=[Column('Has association?'),
Column('Min'),
Column('Max')])
self.__left_frame = ttk.Frame(self)
# Cmp label
self.__cmp_label_var = tk.StringVar(value='')
self.__cmp_label = ttk.Label(self.__left_frame,
textvariable=self.__cmp_label_var,
anchor=tk.CENTER,
style='Big.TLabel')
# Has association checkbox
self.__has_association_checkbox_var = tk.BooleanVar(value=False)
self.__has_association_checkbox_var.trace(
'w', self.__on_has_association_changed)
self.__has_association_checkbox_label = ttk.Label(
self.__left_frame, text='Has association?')
self.__has_association_checkbox = ttk.Checkbutton(
self.__left_frame,
state=tk.DISABLED,
variable=self.__has_association_checkbox_var)
# Has min checkbox
self.__has_min_checkbox_var = tk.BooleanVar(value=False)
self.__has_min_checkbox_var.trace('w', self.__on_has_min_changed)
self.__has_min_checkbox_label = ttk.Label(self.__left_frame,
text='Has min?')
self.__has_min_checkbox = ttk.Checkbutton(
self.__left_frame,
state=tk.DISABLED,
variable=self.__has_min_checkbox_var)
# Min spinbox
self.__min_spinbox_var = tk.IntVar(value='')
self.__min_spinbox_var.trace('w', self.__on_min_changed)
self.__min_spinbox = ttk.Spinbox(self.__left_frame,
from_=0,
to=math.inf,
state=tk.DISABLED,
textvariable=self.__min_spinbox_var,
font=FONT)
# Has max checkbox
self.__has_max_checkbox_var = tk.BooleanVar(value=False)
self.__has_max_checkbox_var.trace('w', self.__on_has_max_changed)
self.__has_max_checkbox_label = ttk.Label(self.__left_frame,
text='Has max?')
self.__has_max_checkbox = ttk.Checkbutton(
self.__left_frame,
state=tk.DISABLED,
variable=self.__has_max_checkbox_var)
# Max spinbox
self.__max_spinbox_var = tk.IntVar(value='')
self.__max_spinbox_var.trace('w', self.__on_max_changed)
self.__max_spinbox = ttk.Spinbox(self.__left_frame,
from_=0,
to=math.inf,
state=tk.DISABLED,
textvariable=self.__max_spinbox_var,
font=FONT)
def _setup_layout(self):
self.__taxonomy_tree.grid(row=0, column=1, sticky=tk.NSEW)
self.__left_frame.grid(row=0,
column=0,
sticky=tk.NSEW,
pady=FRAME_PAD_Y,
padx=FRAME_PAD_X)
self.__cmp_label.grid(row=0,
column=0,
columnspan=4,
sticky=tk.EW,
pady=CONTROL_PAD_Y)
self.__has_association_checkbox_label.grid(row=1,
column=0,
columnspan=2,
sticky=tk.W,
pady=CONTROL_PAD_Y)
self.__has_association_checkbox.grid(row=1,
column=2,
columnspan=2,
sticky=tk.E,
pady=CONTROL_PAD_Y)
self.__has_min_checkbox_label.grid(row=2,
column=0,
sticky=tk.W,
pady=CONTROL_PAD_Y)
self.__has_min_checkbox.grid(row=2,
column=1,
sticky=tk.E,
pady=CONTROL_PAD_Y)
self.__has_max_checkbox_label.grid(row=2,
column=2,
sticky=tk.W,
pady=CONTROL_PAD_Y)
self.__has_max_checkbox.grid(row=2,
column=3,
sticky=tk.E,
pady=CONTROL_PAD_Y)
self.__min_spinbox.grid(row=3,
column=0,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__max_spinbox.grid(row=3,
column=2,
columnspan=2,
sticky=tk.NSEW,
pady=CONTROL_PAD_Y)
self.__left_frame.columnconfigure(0, weight=1)
self.__left_frame.columnconfigure(1, weight=1)
self.__left_frame.columnconfigure(2, weight=1)
self.__left_frame.columnconfigure(3, weight=1)
self.rowconfigure(0, weight=1)
self.columnconfigure(0, weight=1, uniform='fred')
self.columnconfigure(1, weight=3, uniform='fred')
# SubscribesToListeners
def _subscribe_to_events(self):
pub.subscribe(self.__on_taxonomy_edited, actions.TAXONOMY_EDITED)
pub.subscribe(self.__on_taxonomy_edited, actions.MODEL_LOADED)
pub.subscribe(self._reset, actions.RESET)
# Taxonomy Treeview
def __on_select_tree_item(self, cmp_id: int) -> None:
"""Executed whenever a tree item is selected (by mouse click).
:param cmp_id: Id of the selected component.
"""
selected_cmp = self.__state.model.get_component(id_=cmp_id)
if selected_cmp:
change_controls_state(tk.NORMAL, self.__has_association_checkbox)
self.__selected_component = selected_cmp
if selected_cmp.association:
self.__has_association_checkbox_var.set(True)
change_controls_state(tk.NORMAL, self.__has_min_checkbox,
self.__has_max_checkbox)
if selected_cmp.association.min_:
self.__has_min_checkbox_var.set(True)
self.__min_spinbox_var.set(selected_cmp.association.min_)
change_controls_state(tk.NORMAL, self.__min_spinbox)
else:
self.__has_min_checkbox_var.set(False)
change_controls_state(tk.DISABLED, self.__min_spinbox)
self.__min_spinbox_var.set('')
if selected_cmp.association.max_:
self.__has_max_checkbox_var.set(True)
self.__max_spinbox_var.set(selected_cmp.association.max_)
change_controls_state(tk.NORMAL, self.__max_spinbox)
else:
self.__has_max_checkbox_var.set(False)
change_controls_state(tk.DISABLED, self.__max_spinbox)
self.__max_spinbox_var.set('')
else:
self.__has_association_checkbox_var.set(False)
self.__has_min_checkbox_var.set(
False) # Reset and block controls
self.__has_max_checkbox_var.set(False)
self.__min_spinbox_var.set('')
self.__max_spinbox_var.set('')
change_controls_state(tk.DISABLED, self.__has_max_checkbox,
self.__has_min_checkbox,
self.__max_spinbox, self.__min_spinbox)
self.__cmp_label_var.set(trim_string(selected_cmp.name, length=20))
@staticmethod
def __extract_values(cmp: Component) -> Tuple[Any, ...]:
"""Extracts the data of the component to show in the taxonomy view.
:param cmp: Component from which to extract the data.
:return: Tuple containing data about component
(has association?, min_, max_?).
"""
has_association = ''
min_ = ''
max_ = ''
if cmp.association:
has_association = 'Yes'
min_ = cmp.association.min_ if cmp.association.min_ is not None else ''
max_ = cmp.association.max_ if cmp.association.max_ is not None else ''
return has_association, min_, max_
def __build_tree(self) -> None:
"""Fills the tree view with components from model."""
self.__taxonomy_tree.set_items(self.__state.model.taxonomy)
# Resetable
def _reset(self) -> None:
self.__taxonomy_tree.set_items([])
self.__selected_component = None
# Set entries to default
self.__has_association_checkbox_var.set(False)
self.__has_min_checkbox_var.set(False)
self.__has_max_checkbox_var.set(False)
self.__min_spinbox_var.set('')
self.__max_spinbox_var.set('')
self.__cmp_label_var.set('')
# Disable items
change_controls_state(tk.DISABLED, self.__has_association_checkbox,
self.__has_min_checkbox, self.__has_max_checkbox,
self.__min_spinbox, self.__max_spinbox)
def __on_taxonomy_edited(self) -> None:
"""Executed whenever the structure of the taxonomy changes."""
self._reset()
self.__build_tree()
def __on_has_association_changed(self, *_):
"""Executed whenever the __has_association_checkbox is toggled"""
if self.__selected_component:
has_association = self.__has_association_checkbox_var.get()
if has_association:
if not self.__selected_component.association:
self.__selected_component.association = Association()
change_controls_state(tk.NORMAL, self.__has_min_checkbox,
self.__has_max_checkbox)
else:
self.__has_min_checkbox_var.set(
False) # Reset and block controls
self.__has_max_checkbox_var.set(False)
self.__min_spinbox_var.set('')
self.__max_spinbox_var.set('')
change_controls_state(tk.DISABLED, self.__has_max_checkbox,
self.__has_min_checkbox,
self.__max_spinbox, self.__min_spinbox)
self.__selected_component.association = None
self.__taxonomy_tree.update_values(self.__selected_component)
def __on_has_min_changed(self, *_):
"""Executed whenever the __has_min_checkbox is toggled"""
if self.__selected_component:
has_min = self.__has_min_checkbox_var.get()
if has_min:
change_controls_state(tk.NORMAL, self.__min_spinbox)
if self.__selected_component.association and self.__selected_component.association.min_ is not None:
self.__min_spinbox_var.set(
self.__selected_component.association.min_)
else:
self.__min_spinbox_var.set(0)
self.__selected_component.association.min_ = 0
else:
if self.__selected_component.association:
self.__selected_component.association.min_ = None
change_controls_state(tk.DISABLED, self.__min_spinbox)
self.__min_spinbox_var.set('')
def __on_has_max_changed(self, *_):
"""Executed whenever the __has_max_checkbox_var is toggled"""
if self.__selected_component:
has_max = self.__has_max_checkbox_var.get()
if has_max:
change_controls_state(tk.NORMAL, self.__max_spinbox)
if self.__selected_component.association:
if self.__selected_component.association.max_ is not None:
self.__max_spinbox_var.set(
self.__selected_component.association.max_)
else:
if self.__selected_component.association.min_ is not None:
# If component has a minimum association, set the value of Spinbox to it
self.__max_spinbox_var.set(
self.__selected_component.association.min_)
else:
# Otherwise set it to 0
self.__max_spinbox_var.set(0)
self.__selected_component.association.max_ = 0
else:
if self.__selected_component.association:
self.__selected_component.association.max_ = None
change_controls_state(tk.DISABLED, self.__max_spinbox)
self.__max_spinbox_var.set('')
def __on_min_changed(self, *_):
"""Executed whenever the __min_spinbox_var value changes."""
if self.__selected_component and self.__selected_component.association:
# This gets triggered at unpredicted moments (e.g. enabling and disabling widgets
# so it's necessary to check this condition.
try:
min_ = self.__min_spinbox_var.get()
self.__selected_component.association.min_ = min_
if self.__selected_component.association.max_ is not None \
and self.__selected_component.association.max_ < min_: # If max < min; set max to min
self.__selected_component.association.max_ = min_
self.__max_spinbox_var.set(min_)
except tk.TclError:
self.__selected_component.association.min_ = None
finally:
self.__taxonomy_tree.update_values(self.__selected_component)
def __on_max_changed(self, *_):
"""Executed whenever the __max_spinbox_var value changes."""
if self.__selected_component and self.__selected_component.association:
try:
max_ = self.__max_spinbox_var.get()
self.__selected_component.association.max_ = max_
if self.__selected_component.association.min_ is not None \
and self.__selected_component.association.min_ > max_: # If min > max; set min to max
self.__selected_component.association.min_ = max_
self.__min_spinbox_var.set(max_)
except tk.TclError:
self.__selected_component.association.max_ = None
finally:
self.__taxonomy_tree.update_values(self.__selected_component)