def __init__(self, node_block: NodeBlock):
super().__init__(node_block.node.name, "")
self.layout = QGridLayout()
# Connect node
self.node = node_block
self.parameters = dict()
self.edited_data = dict()
self.has_edits = False
# Build main_layout
title_label = CustomLabel("Edit parameters")
title_label.setStyleSheet(style.NODE_LABEL_STYLE)
title_label.setAlignment(Qt.AlignCenter)
self.layout.addWidget(title_label, 0, 0, 1, 2)
# Input box
in_dim_label = CustomLabel("Input")
in_dim_label.setStyleSheet(style.IN_DIM_LABEL_STYLE)
in_dim_label.setAlignment(Qt.AlignRight)
self.layout.addWidget(in_dim_label, 1, 0)
in_dim_box = CustomTextBox(','.join(map(str, node_block.in_dim)))
in_dim_box.setValidator(ArithmeticValidator.TENSOR)
self.layout.addWidget(in_dim_box, 1, 1)
self.parameters["in_dim"] = in_dim_box
if not node_block.is_head:
in_dim_box.setReadOnly(True)
# Display parameters if present
counter = 2
if node_block.node.param:
counter = self.append_node_params(node_block.node, node_block.block_data)
# "Apply" button which saves changes
apply_button = CustomButton("Apply")
apply_button.clicked.connect(self.save_data)
self.layout.addWidget(apply_button, counter, 0)
# "Cancel" button which closes the dialog without saving
cancel_button = CustomButton("Cancel")
cancel_button.clicked.connect(self.close)
self.layout.addWidget(cancel_button, counter, 1)
self.layout.setColumnStretch(0, 1)
self.layout.setColumnStretch(1, 1)
self.render_layout()
def __init__(self, node_block: NodeBlock):
super().__init__(node_block.node.name, "")
self.layout = QGridLayout()
# Connect node
self.node = node_block
self.new_in_dim = ','.join(map(str, node_block.in_dim))
self.in_dim_box = CustomTextBox()
self.has_edits = False
# Build main_layout
title_label = CustomLabel("Edit network input")
title_label.setStyleSheet(style.NODE_LABEL_STYLE)
title_label.setAlignment(Qt.AlignCenter)
self.layout.addWidget(title_label, 0, 0, 1, 2)
# Input box
in_dim_label = CustomLabel("Input shape")
in_dim_label.setStyleSheet(style.IN_DIM_LABEL_STYLE)
in_dim_label.setAlignment(Qt.AlignRight)
self.layout.addWidget(in_dim_label, 1, 0)
self.in_dim_box.setText(self.new_in_dim)
self.in_dim_box.setValidator(ArithmeticValidator.TENSOR)
self.layout.addWidget(self.in_dim_box, 1, 1)
if not node_block.is_head:
self.in_dim_box.setReadOnly(True)
# "Apply" button which saves changes
apply_button = CustomButton("Apply")
apply_button.clicked.connect(self.save_data)
self.layout.addWidget(apply_button, 2, 0)
# "Cancel" button which closes the dialog without saving
cancel_button = CustomButton("Cancel")
cancel_button.clicked.connect(self.close)
self.layout.addWidget(cancel_button, 2, 1)
self.layout.setColumnStretch(0, 1)
self.layout.setColumnStretch(1, 1)
self.render_layout()
def __init__(self, message):
super().__init__("", message)
# Set title label
title_label = CustomLabel("Input required")
title_label.setStyleSheet(style.NODE_LABEL_STYLE)
title_label.setAlignment(Qt.AlignCenter)
# Set message label
mess_label = CustomLabel("\n" + self.content + "\n")
mess_label.setAlignment(Qt.AlignCenter)
# Set input reading
self.input = None
input_line = CustomTextBox()
input_line.setValidator(QRegExpValidator(QRegExp(
ArithmeticValidator.TENSOR.regExp().pattern() + "|" +
ArithmeticValidator.TENSOR_LIST.regExp().pattern())))
# Add buttons to close the dialog
confirm_button = CustomButton("Ok")
confirm_button.clicked.connect(self.save_input)
cancel_button = CustomButton("Cancel")
cancel_button.clicked.connect(self.cancel)
buttons = QWidget()
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(confirm_button)
buttons_layout.addWidget(cancel_button)
buttons.setLayout(buttons_layout)
# Compose widgets
self.layout.addWidget(title_label)
self.layout.addWidget(mess_label)
self.layout.addWidget(input_line)
self.layout.addWidget(buttons)
self.render_layout()
def __init__(self, property_block: PropertyBlock):
super().__init__("Edit property", "")
self.property_block = property_block
self.new_property = self.property_block.smt_string
self.has_edits = False
self.layout = QGridLayout()
# Build main_layout
title_label = CustomLabel("SMT property")
title_label.setStyleSheet(style.NODE_LABEL_STYLE)
title_label.setAlignment(Qt.AlignCenter)
self.layout.addWidget(title_label, 0, 0, 1, 2)
# Input box
smt_label = CustomLabel("SMT-LIB definition")
smt_label.setStyleSheet(style.IN_DIM_LABEL_STYLE)
smt_label.setAlignment(Qt.AlignRight)
self.layout.addWidget(smt_label, 1, 0)
self.smt_box = CustomTextArea()
self.smt_box.insertPlainText(self.new_property)
self.layout.addWidget(self.smt_box, 1, 1)
# "Apply" button which saves changes
apply_button = CustomButton("Apply")
apply_button.clicked.connect(self.save_data)
self.layout.addWidget(apply_button, 2, 0)
# "Cancel" button which closes the dialog without saving
cancel_button = CustomButton("Cancel")
cancel_button.clicked.connect(self.close)
self.layout.addWidget(cancel_button, 2, 1)
self.layout.setColumnStretch(0, 1)
self.layout.setColumnStretch(1, 1)
self.render_layout()
def show_layout(self, name: str) -> None:
"""
This method displays a grid layout initialized by the
dictionary of parameters and default values.
Parameters
----------
name : str
The name of the main parameter to which
the dictionary is related.
"""
title = CustomLabel(name.replace(':', ': '))
title.setAlignment(Qt.AlignCenter)
self.grid_layout.addWidget(title, 0, 0, 1, 2)
widgets_2level = dict()
count = 1
for k, v in self.gui_params[name].items():
# Activation functions for dynamic widgets
def activation_combo(super_key: str, key: str):
return lambda: self.update_dict_value(
name, key, widgets_2level[f"{super_key}:{key}"][1].
currentText())
def activation_line(super_key: str, key: str):
return lambda: self.update_dict_value(
name, key, widgets_2level[f"{super_key}:{key}"][1].text())
w_label = CustomLabel(k)
w_label.setToolTip(v.get("description"))
if v["type"] == "bool":
cb = CustomComboBox()
cb.addItems([str(v["value"]), str(not v["value"])])
widgets_2level[f"{name}:{k}"] = (w_label, cb)
widgets_2level[f"{name}:{k}"][1].activated.connect(
activation_combo(name, k))
elif "allowed" in v.keys():
cb = CustomComboBox()
cb.addItems(v["allowed"])
widgets_2level[f"{name}:{k}"] = (w_label, cb)
widgets_2level[f"{name}:{k}"][1].activated.connect(
activation_combo(name, k))
else:
widgets_2level[f"{name}:{k}"] = (w_label,
CustomTextBox(str(
v["value"])))
widgets_2level[f"{name}:{k}"][1].textChanged.connect(
activation_line(name, k))
if v["type"] == "int":
widgets_2level[f"{name}:{k}"][1].setValidator(
ArithmeticValidator.INT)
elif v["type"] == "float":
widgets_2level[f"{name}:{k}"][1].setValidator(
ArithmeticValidator.FLOAT)
elif v["type"] == "tensor" or \
v["type"] == "tuple":
widgets_2level[f"{name}:{k}"][1].setValidator(
ArithmeticValidator.TENSOR)
self.grid_layout.addWidget(widgets_2level[f"{name}:{k}"][0], count,
0)
self.grid_layout.addWidget(widgets_2level[f"{name}:{k}"][1], count,
1)
count += 1
def __init__(self, nn: NeuralNetwork):
super().__init__("Train Network")
# Training elements
self.nn = nn
self.is_nn_trained = False
self.dataset_path = ""
self.dataset_params = dict()
self.dataset_transform = tr.Compose([])
self.params = utility.read_json(ROOT_DIR + '/res/json/training.json')
self.gui_params = dict()
self.loss_f = ''
self.metric = ''
self.grid_layout = QGridLayout()
# Dataset
dt_label = CustomLabel("Dataset")
dt_label.setAlignment(Qt.AlignCenter)
dt_label.setStyleSheet(style.NODE_LABEL_STYLE)
self.layout.addWidget(dt_label)
dataset_layout = QHBoxLayout()
self.widgets["dataset"] = CustomComboBox()
self.widgets["dataset"].addItems(
["MNIST", "Fashion MNIST", "Custom data source..."])
self.widgets["dataset"].setCurrentIndex(-1)
self.widgets["dataset"].activated \
.connect(lambda: self.setup_dataset(self.widgets["dataset"].currentText()))
dataset_layout.addWidget(CustomLabel("Dataset"))
dataset_layout.addWidget(self.widgets["dataset"])
self.layout.addLayout(dataset_layout)
transform_layout = QHBoxLayout()
self.widgets["transform"] = CustomComboBox()
self.widgets["transform"].addItems([
"No transform", "Convolutional MNIST", "Fully Connected MNIST",
"Custom..."
])
self.widgets["transform"].activated \
.connect(lambda: self.setup_transform(self.widgets["transform"].currentText()))
transform_layout.addWidget(CustomLabel("Dataset transform"))
transform_layout.addWidget(self.widgets["transform"])
self.layout.addLayout(transform_layout)
# Separator
sep_label = CustomLabel("Training parameters")
sep_label.setAlignment(Qt.AlignCenter)
sep_label.setStyleSheet(style.NODE_LABEL_STYLE)
self.layout.addWidget(sep_label)
# Main body
# Activation functions for dynamic widgets
def activation_combo(key: str):
return lambda: self.update_grid_view(
f"{key}:{self.widgets[key].currentText()}")
def activation_line(key: str):
return lambda: self.update_dict_value(key, "", self.widgets[key].
text())
body_layout = self.create_widget_layout(self.params, activation_combo,
activation_line)
body_layout.addLayout(self.grid_layout)
self.grid_layout.setAlignment(Qt.AlignTop)
self.layout.addLayout(body_layout)
# Buttons
btn_layout = QHBoxLayout()
self.train_btn = CustomButton("Train network")
self.train_btn.clicked.connect(self.train_network)
self.cancel_btn = CustomButton("Cancel")
self.cancel_btn.clicked.connect(self.close)
btn_layout.addWidget(self.train_btn)
btn_layout.addWidget(self.cancel_btn)
self.layout.addLayout(btn_layout)
self.render_layout()
def append_node_params(self, node: NetworkNode, current_data: dict) -> int:
"""
This method adds to the dialog layer the editable parameters of
the node, and returns the last row counter for the grid main_layout.
Attributes
----------
node: NetworkNode
The node whose parameters are displayed.
current_data: dict
The node current data.
Returns
----------
int
The last row counter.
"""
# Init column counter
counter = 2
# Display parameter labels
for param, value in node.param.items():
param_label = CustomLabel(param)
if node.param[param]["editable"] == "false":
param_label.setStyleSheet(style.UNEDITABLE_PARAM_LABEL_STYLE)
param_label.setAlignment(Qt.AlignRight)
# Set the tooltip of the input with the description
param_label.setToolTip("<" + value["type"] + ">: "
+ value["description"])
self.layout.addWidget(param_label, counter, 0)
# Display parameter values
if value["type"] == "boolean":
line = CustomComboBox()
line.addItem("True")
line.addItem("False")
line.setPlaceholderText(str(current_data[param]))
else:
line = CustomTextBox()
if node.param[param]["editable"] == "false":
line.setReadOnly(True)
if isinstance(current_data[param], Tensor) or isinstance(current_data[param], np.ndarray):
line.setText("(" + ','.join(map(str, current_data[param].shape)) + ")")
elif isinstance(current_data[param], tuple):
line.setText(','.join(map(str, current_data[param])))
else:
line.setText(str(current_data[param]))
# Set type validator
validator = None
if value["type"] == "int":
validator = ArithmeticValidator.INT
elif value["type"] == "float":
validator = ArithmeticValidator.FLOAT
elif value["type"] == "Tensor" or value["type"] == "list of ints":
validator = ArithmeticValidator.TENSOR
elif value["type"] == "list of Tensors":
validator = ArithmeticValidator.TENSOR_LIST
line.setValidator(validator)
if node.param[param]["editable"] == "false":
line.setStyleSheet(style.UNEDITABLE_VALUE_LABEL_STYLE)
self.layout.addWidget(line, counter, 1)
# Keep trace of CustomTextBox objects
self.parameters[param] = line
counter += 1
return counter
def __init__(self, property_block: PropertyBlock):
super().__init__("Edit property", "")
self.property_block = property_block
self.has_edits = False
self.property_list = []
self.viewer = CustomTextArea()
self.viewer.setReadOnly(True)
self.viewer.setFixedHeight(100)
grid = QGridLayout()
# Build main_layout
title_label = CustomLabel("Polyhedral property")
title_label.setStyleSheet(style.NODE_LABEL_STYLE)
title_label.setAlignment(Qt.AlignCenter)
grid.addWidget(title_label, 0, 0, 1, 3)
# Labels
var_label = CustomLabel("Variable")
var_label.setStyleSheet(style.IN_DIM_LABEL_STYLE)
var_label.setAlignment(Qt.AlignRight)
grid.addWidget(var_label, 1, 0)
relop_label = CustomLabel("Operator")
relop_label.setStyleSheet(style.IN_DIM_LABEL_STYLE)
relop_label.setAlignment(Qt.AlignCenter)
grid.addWidget(relop_label, 1, 1)
value_label = CustomLabel("Value")
value_label.setStyleSheet(style.IN_DIM_LABEL_STYLE)
value_label.setAlignment(Qt.AlignLeft)
grid.addWidget(value_label, 1, 2)
self.var_cb = CustomComboBox()
for v in property_block.variables:
self.var_cb.addItem(v)
grid.addWidget(self.var_cb, 2, 0)
self.op_cb = CustomComboBox()
operators = ["<=", "<", ">", ">="]
for o in operators:
self.op_cb.addItem(o)
grid.addWidget(self.op_cb, 2, 1)
self.val = CustomTextBox()
self.val.setValidator(ArithmeticValidator.FLOAT)
grid.addWidget(self.val, 2, 2)
# "Add" button which adds the constraint
add_button = CustomButton("Add")
add_button.clicked.connect(
lambda: self.add_entry(str(self.var_cb.currentText()), str(self.op_cb.currentText()), self.val.text()))
grid.addWidget(add_button, 3, 0)
# "Save" button which saves the state
save_button = CustomButton("Save")
save_button.clicked.connect(self.save_property)
grid.addWidget(save_button, 3, 1)
# "Cancel" button which closes the dialog without saving
cancel_button = CustomButton("Cancel")
cancel_button.clicked.connect(self.close)
grid.addWidget(cancel_button, 3, 2)
grid.setColumnStretch(0, 1)
grid.setColumnStretch(1, 1)
grid.setColumnStretch(2, 1)
self.layout.addLayout(grid)
self.layout.addWidget(self.viewer, 3)
self.render_layout()
class BlockInspector(QWidget):
"""
This class contains the widget for displaying the description of a network
block in the ParamToolbar. Each block attribute is labeled and wrapped
in a drop-down box.
Attributes
----------
layout : QVBoxLayout
Vertical main_layout of the widget.
title_label : CustomLabel
Title of the widget.
description_label : CustomLabel
Description of the block.
parameters : QWidget
Container of parameters.
parameters_label : CustomLabel
Label of parameters.
parameters_layout : QVBoxLayout
Vertical main_layout of parameters.
inputs : QWidget
Container of inputs.
inputs_label : CustomLabel
Label of inputs.
inputs_layout : QVBoxLayout
Vertical main_layout of inputs.
outputs : QWidget
Container of outputs.
outputs_label : CustomLabel
Label of outputs.
outputs_layout : QVBoxLayout
Vertical main_layout of outputs.
"""
def __init__(self, block: NodeBlock):
super().__init__()
self.setStyleSheet(style.BLOCK_BOX_STYLE)
self.layout = QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 10, 0)
self.setLayout(self.layout)
self.adjustSize()
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
# Widget title
self.title_label = CustomLabel()
self.title_label.setStyleSheet(style.TITLE_LABEL_STYLE)
self.title_label.setText(block.block_id + ":" + block.node.name)
# NodeBlock description
self.description_label = CustomLabel()
self.description_label.setStyleSheet(style.DESCRIPTION_STYLE)
self.description_label.setWordWrap(True)
self.description_label.setAlignment(Qt.AlignLeft)
self.description_label.setText(block.node.descr)
self.description_label.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Minimum)
# Parameters section
if block.node.param:
self.parameters_label = CustomLabel("Parameters")
self.parameters_label.setStyleSheet(style.NODE_LABEL_STYLE)
self.parameters = QWidget()
self.parameters_layout = QVBoxLayout()
self.parameters_layout.setSpacing(0)
self.parameters.setLayout(self.parameters_layout)
self.parameters.setStyleSheet("padding: 0px")
for par, values in block.node.param.items():
self.parameters_layout.addWidget(DropDownLabel(par, values))
# Inputs section
if block.node.input:
self.inputs_label = CustomLabel("Input")
self.inputs_label.setStyleSheet(style.NODE_LABEL_STYLE)
self.inputs = QWidget()
self.inputs_layout = QVBoxLayout()
self.inputs_layout.setSpacing(0)
self.inputs.setLayout(self.inputs_layout)
self.inputs.setStyleSheet("padding: 0px")
for par, values in block.node.input.items():
self.inputs_layout.addWidget(DropDownLabel(par, values))
# Outputs section
if block.node.output:
self.outputs_label = CustomLabel("Output")
self.outputs_label.setStyleSheet(style.NODE_LABEL_STYLE)
self.outputs = QWidget()
self.outputs_layout = QVBoxLayout()
self.outputs_layout.setSpacing(0)
self.outputs.setLayout(self.outputs_layout)
self.outputs.setStyleSheet("padding: 0px")
for par, values in block.node.output.items():
self.outputs_layout.addWidget(DropDownLabel(par, values))
# Compose widget
self.layout.addWidget(self.title_label)
self.layout.addWidget(self.description_label)
if block.node.param:
self.layout.addWidget(self.parameters_label)
self.layout.addWidget(self.parameters)
if block.node.input:
self.layout.addWidget(self.inputs_label)
self.layout.addWidget(self.inputs)
if block.node.output:
self.layout.addWidget(self.outputs_label)
self.layout.addWidget(self.outputs)
class BlocksToolbar(QToolBar):
"""
This class defines a toolbar containing all the blocks available to draw a
neural network: each type of block is read from a file in order to build a list
of NetworkNode objects to be displayed.
Attributes
----------
NODE_FILE_PATH : str
Path of the JSON file containing all information about the implemented
nodes available to displaying.
blocks : dict
Dictionary of blocks connecting each block name with a NetworkNode.
properties : dict
Dictionary of properties connecting each property name with a NetworkProperty.
f_buttons : dict
Dictionary of buttons connecting a function name to a CustomButton.
b_buttons : dict
Dictionary connecting each block name to a CustomButton, which
makes the corresponding node appear.
p_buttons : dict
Dictionary connecting each property name to a CustomButton, which
makes the corresponding property appear.
toolbar_tools_label : CustomLabel
Label of the toolbar introducing tools.
toolbar_blocks_label : CustomLabel
Label of the toolbar introducing blocks types.
toolbar_properties_label : CustomLabel
Label of the toolbar introducing property names.
isToolbar_tools_label_visible : bool
Tells if the tools button are visible in the toolbar.
isToolbar_blocks_label_visible : bool
Tells if the blocks button are visible in the toolbar.
isToolbar_properties_label_visible : bool
Tells if the properties button are visible in the toolbar.
Methods
----------
__display_tools()
This method displays on the toolbar the CustomButtons related to
available tools.
__init_blocks()
This method reads from file all types of blocks storing them.
__display_blocks()
This method displays on the toolbar all buttons related to types of
blocks.
change_tools_mode()
This method changes the visibility of the tools section of the toolbar.
change_blocks_mode()
This method changes the visibility of the blocks section of the toolbar.
show_section(CustomLabel, dict)
This method shows the given objects.
hide_section(CustomLabel, dict)
This method hides the given objects.
"""
def __init__(self, node_file_path: str):
super().__init__()
self.NODE_FILE_PATH = node_file_path
self.setContextMenuPolicy(Qt.PreventContextMenu)
self.blocks = dict()
self.properties = dict()
# Graphic buttons
self.f_buttons = dict()
self.b_buttons = dict()
self.p_buttons = dict()
# Labels
self.toolbar_tools_label = CustomLabel("Tools")
self.toolbar_blocks_label = CustomLabel("Nodes")
self.toolbar_properties_label = CustomLabel("Properties")
self.isToolbar_tools_label_visible = True
self.isToolbar_blocks_label_visible = True
self.isToolbar_properties_label_visible = True
# Setup view
self.__display_tools()
self.__init_blocks()
self.__display_blocks()
self.__init_properties()
self.__display_properties()
# Toolbar style
for item in self.children():
if type(item) is QToolButton:
item.setStyleSheet("background-color: " + style.GREEN_2)
self.setStyleSheet(style.TOOLBAR_STYLE)
self.setOrientation(Qt.Vertical)
self.setMovable(False)
self.setFloatable(False)
def __init_blocks(self):
"""
Uploading blocks from a JSON file storing them in a dictionary of
NetworkNode objects.
"""
with open(self.NODE_FILE_PATH) as json_file:
blocks_dict = json.loads(json_file.read())
for k, b in blocks_dict.items():
self.blocks[k] = NetworkNode(k, b["name"], b["input"],
b["parameters"], b["output"],
b["description"])
button = NodeButton(k, self.blocks[k])
button.setToolTip(b["description"])
self.b_buttons[k] = button
def __init_properties(self):
props = ("Generic SMT", "Polyhedral")
for k in props:
button = PropertyButton(k)
button.setToolTip(k)
self.p_buttons[k] = button
def __display_tools(self):
"""
This method adds to the toolbar all buttons related to available tools,
displaying them in rows in order to have a flexible main_layout in every
position of the toolbar.
"""
# Setting the label of the toolbar
self.addWidget(self.toolbar_tools_label)
self.toolbar_tools_label.setAlignment(Qt.AlignCenter)
self.toolbar_tools_label.setStyleSheet(style.NODE_LABEL_STYLE)
# Setting the first row with horizontal main_layout
row_1 = QWidget()
row_1_layout = QHBoxLayout()
row_1_layout.setSpacing(0)
row_1_layout.setContentsMargins(0, 0, 0, 0)
row_1_layout.setAlignment(Qt.AlignCenter)
row_1.setLayout(row_1_layout)
# DrawLine mode button
draw_line_button = CustomButton()
draw_line_button.setIcon(QIcon(ROOT_DIR + "/res/icons/line.png"))
draw_line_button.setFixedSize(40, 40)
draw_line_button.setToolTip("Draw line")
# Insert block button
insert_block_button = CustomButton()
insert_block_button.setIcon(QIcon(ROOT_DIR + "/res/icons/insert.png"))
insert_block_button.setFixedSize(40, 40)
insert_block_button.setToolTip("Insert block in edge")
# Save in a dictionary button references and add the rows to the
# toolbar
row_1_layout.addWidget(draw_line_button)
row_1_layout.addWidget(insert_block_button)
self.f_buttons["draw_line"] = draw_line_button
self.f_buttons["insert_block"] = insert_block_button
self.addWidget(row_1)
self.addSeparator()
def __display_blocks(self):
"""
Graphical blocks are displayed in a vertical main_layout, which is put in
a movable toolbar of fixed size.
"""
# Labels
self.toolbar_blocks_label.setAlignment(Qt.AlignCenter)
self.toolbar_blocks_label.setStyleSheet(style.NODE_LABEL_STYLE)
# Buttons
self.addWidget(self.toolbar_blocks_label)
for b in self.b_buttons.values():
self.addWidget(b)
def __display_properties(self):
"""
Graphical properties are displayed in a vertical main_layout, which is put in
a movable toolbar of fixed size.
"""
# Labels
self.toolbar_properties_label.setAlignment(Qt.AlignCenter)
self.toolbar_properties_label.setStyleSheet(style.NODE_LABEL_STYLE)
# Buttons
self.addWidget(self.toolbar_properties_label)
for p in self.p_buttons.values():
self.addWidget(p)
def change_tools_mode(self):
"""
This method handles the visibility of the tool section of the toolbar.
If all sections are not visible, then the toolbar itself is hidden,
while if the toolbar was hidden, it is shown with the tools section.
"""
if not self.isToolbar_tools_label_visible:
self.show_section(self.toolbar_tools_label, self.f_buttons)
self.isToolbar_tools_label_visible = True
if not self.isToolbar_blocks_label_visible:
self.show()
else:
self.hide_section(self.toolbar_tools_label, self.f_buttons)
self.isToolbar_tools_label_visible = False
if not self.isToolbar_blocks_label_visible:
self.hide()
def change_blocks_mode(self):
"""
This method handles the visibility of the blocks section of the toolbar.
If all sections are not visible, then the toolbar itself is hidden,
while if the toolbar was hidden, it is shown with the blocks section.
"""
if not self.isToolbar_blocks_label_visible:
self.show_section(self.toolbar_blocks_label, self.b_buttons)
self.isToolbar_blocks_label_visible = True
if not self.isToolbar_tools_label_visible:
self.show()
else:
self.hide_section(self.toolbar_blocks_label, self.b_buttons)
self.isToolbar_blocks_label_visible = False
if not self.isToolbar_tools_label_visible:
self.hide()
@staticmethod
def show_section(label: CustomLabel, buttons: dict):
"""
This method shows the given dictionary of buttons with its label.
Parameters
----------
label: CustomLabel
buttons: dict
"""
label.show()
label.setStyleSheet(style.NODE_LABEL_STYLE)
for tool in buttons.values():
tool.show()
@staticmethod
def hide_section(label: CustomLabel, buttons: dict):
"""
This method hides the given dictionary of buttons with its label.
Parameters
----------
label: CustomLabel
buttons: dict
"""
label.hide()
label.setStyleSheet(style.HIDDEN_LABEL_STYLE)
for tool in buttons.values():
tool.hide()
if type(tool) is NodeButton:
tool.setStyleSheet(style.HIDDEN_LABEL_STYLE)
class DropDownLabel(QWidget):
"""
This widget displays a generic parameter name and value.
It features a drop-down arrow button that shows or hides
the description.
Attributes
----------
layout : QVBoxLayout
Vertical main_layout of the widget.
top : QWidget
First part of the widget with name, type and default value of the
parameter.
top_layout : QHBoxLayout
Horizontal main_layout of the top of the widget.
name_label : CustomLabel
Id and type of the object.
type_label : CustomLabel
Object type.
default_label : CustomLabel
Eventual default value.
down_button : CustomButton
Arrow button to show/hide the description of the parameter.
description : CustomLabel
Description of the parameter.
Methods
----------
change_description_mode()
This method shows or hides the description of the parameter.
"""
def __init__(self, name: str, parameters: dict):
super().__init__()
self.layout = QVBoxLayout()
self.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
self.setStyleSheet(style.DROPDOWN_STYLE)
self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Expanding)
# Top bar with short info
self.top = QWidget()
self.top.setContentsMargins(0, 0, 0, 0)
self.top.setStyleSheet(style.DROPDOWN_TOP_STYLE)
self.top_layout = QHBoxLayout()
self.top_layout.setContentsMargins(0, 0, 0, 0)
self.top.setLayout(self.top_layout)
self.name_label = CustomLabel(name)
self.name_label.setAlignment(Qt.AlignLeft)
self.name_label.setStyleSheet(style.DROPDOWN_NAME_STYLE)
self.top_layout.addWidget(self.name_label, Qt.AlignLeft)
self.type_label = CustomLabel(parameters["type"])
self.type_label.setAlignment(Qt.AlignLeft)
self.type_label.setToolTip("Type")
self.type_label.setStyleSheet(style.DROPDOWN_TYPE_STYLE)
self.top_layout.addWidget(self.type_label, Qt.AlignLeft)
if "default" in parameters:
self.default_label = CustomLabel(parameters["default"])
self.default_label.setStyleSheet(style.DROPDOWN_DEFAULT_STYLE)
self.default_label.setToolTip("Default value")
self.default_label.setAlignment(Qt.AlignCenter)
self.top_layout.addWidget(self.default_label, Qt.AlignRight)
self.down_button = CustomButton("\u25bc")
self.down_button.setStyleSheet(style.DROPDOWN_ARROW_STYLE)
self.down_button.clicked.connect(lambda: self.__toggle_visibility())
self.top_layout.addWidget(self.down_button, Qt.AlignRight)
self.layout.addWidget(self.top)
self.description = CustomLabel(parameters["description"])
self.description.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Maximum)
self.description.setWordWrap(True)
self.description.setStyleSheet(style.DESCRIPTION_STYLE)
self.description.hide()
self.layout.addWidget(self.description)
def __toggle_visibility(self):
"""
This method toggles the visibility of the parameter description
changing the arrow icon of the button.
"""
if self.description.isHidden():
self.description.show()
self.down_button.setText("\u25b2")
else:
self.description.hide()
self.down_button.setText("\u25bc")