def connection_changed(self, connected):
build = (self._node is None) and (self._connected != connected
and connected is True)
super(SystemLog, self).connection_changed(connected)
if not build:
return
self._node = nodeFromAddress(self.channel)
self._path = self.channel.replace('SystemLog', 'ClearLog')
vb = QVBoxLayout()
self.setLayout(vb)
gb = QGroupBox('System Log (20 most recent entries)')
vb.addWidget(gb)
vb = QVBoxLayout()
gb.setLayout(vb)
self._systemLog = QTreeWidget()
vb.addWidget(self._systemLog)
self._systemLog.setColumnCount(2)
self._systemLog.setHeaderLabels(['Field', 'Value'])
self._systemLog.setColumnWidth(0, 200)
self._pb = PyDMPushButton(label='Clear Log',
pressValue=1,
init_channel=self._path)
vb.addWidget(self._pb)
def __init__(self, parent, xml):
super().__init__(parent)
self.setWindowTitle("Information")
tree = QTreeWidget()
tree.setColumnCount(2)
tree.setHeaderLabels(["Name", "Value"])
tree.setColumnWidth(0, 200)
tree.setColumnWidth(1, 350)
for stream in xml:
header = xml[stream][2]
header.tag = "Header"
footer = xml[stream][6]
footer.tag = "Footer"
root = et.Element(f"Stream {stream}")
root.extend([header, footer])
populate_tree(tree, root)
tree.expandAll()
vbox = QVBoxLayout(self)
vbox.addWidget(tree)
buttonbox = QDialogButtonBox(QDialogButtonBox.Ok)
vbox.addWidget(buttonbox)
buttonbox.accepted.connect(self.accept)
self.resize(650, 550)
def __init__(self, parent, model):
super(AlgorithmMonitorDialog, self).__init__(parent)
self.tree = QTreeWidget(self)
self.tree.setColumnCount(3)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.tree.setColumnWidth(0, 220)
self.tree.setHeaderLabels(['Algorithm', 'Progress', ''])
header = self.tree.header()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.Fixed)
header.setStretchLastSection(False)
button_layout = QHBoxLayout()
self.close_button = QPushButton('Close')
button_layout.addStretch()
button_layout.addWidget(self.close_button)
layout = QVBoxLayout()
layout.addWidget(self.tree)
layout.addLayout(button_layout)
self.setLayout(layout)
self.setWindowTitle('Mantid - Algorithm progress')
self.setWindowIcon(QIcon(":/MantidPlot_Icon_32offset.png"))
self.resize(500, 300)
self.presenter = AlgorithmProgressDialogPresenter(self, model)
self.presenter.update_gui()
def __init__(self, parent):
super(ProjectWidget, self).__init__("Projects manager", parent)
main_tree_widget = QTreeWidget(self)
# main_layout = QVBoxLayout()
# main_tree_widget.setLayout(main_layout)
self.setObjectName("projects_dock")
self.setAllowedAreas(Qt.AllDockWidgetAreas)
main_tree_widget.setHeaderLabels(["Untitled project"])
# main_tree_widget.setHeaderLabels(["ProjectName"])
# item = QTreeWidgetItem()
for i in range(3):
parent = QTreeWidgetItem(main_tree_widget)
parent.setText(0, "Parent {}".format(i))
parent.setFlags(parent.flags() | Qt.ItemIsTristate | Qt.ItemIsUserCheckable)
for x in range(5):
child = QTreeWidgetItem(parent)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, "Child {}".format(x))
child.setCheckState(0, Qt.Unchecked)
main_tree_widget.currentItemChanged.connect(self.changed_item)
self.setWidget(main_tree_widget)
self.setVisible(False)
print(self.objectName())
def setup_page(self):
self.treeWidget = QTreeWidget(self)
self.treeWidget.setHeaderHidden(True)
self.treeWidget.itemChanged.connect(self.check_changed)
self.layout.addWidget(self.treeWidget)
action = self.create_action()
self.layout.addWidget(action)
def __init__(self, plugin):
plugin.layout_vertical = QVBoxLayout()
plugin.layout_vertical.setContentsMargins(11, 11, 11, 11)
plugin.layout_vertical.setSpacing(6)
plugin.group_box = QGroupBox()
plugin.contents.setLayout(plugin.layout_vertical)
plugin.layout_vertical.setContentsMargins(11, 11, 11, 11)
plugin.group_box_layout = QVBoxLayout(plugin.group_box)
plugin.group_box_layout.setContentsMargins(10, 0, 0, 0)
plugin.group_box_layout.setSpacing(0)
plugin.checkbox_horizontal_layout = QHBoxLayout()
plugin.checkbox_horizontal_layout.setContentsMargins(10, 0, 0, 0)
plugin.checkbox_horizontal_layout.setSpacing(0)
plugin.checkbox_show_mask = QCheckBox("Show Masked Data")
plugin.checkbox_show_mask.setChecked(False)
plugin.checkbox_horizontal_layout.addWidget(plugin.checkbox_show_mask)
plugin.group_box_layout.addLayout(plugin.checkbox_horizontal_layout)
plugin.layout_horizontal_mask_button = QHBoxLayout()
plugin.layout_horizontal_mask_button.setContentsMargins(0, 0, 0, 0)
plugin.layout_horizontal_mask_button.setSpacing(6)
plugin.button_mask_data = QPushButton()
plugin.button_mask_data.setText("Mask Data")
plugin.button_mask_data.setToolTip("Mask data in current ROI")
plugin.button_mask_data.setEnabled(False)
plugin.button_unmask_data = QPushButton()
plugin.button_unmask_data.setText("Unmask Data")
plugin.button_unmask_data.setToolTip(
"Remove mask from data in current ROI")
plugin.button_unmask_data.setEnabled(False)
plugin.layout_horizontal_mask_button.addWidget(plugin.button_mask_data)
plugin.layout_horizontal_mask_button.addWidget(
plugin.button_unmask_data)
plugin.group_box_layout.addLayout(plugin.layout_horizontal_mask_button)
# plugin.layout_vertical.setContentsMargins(11, 11, 11, 11)
# plugin.setMaximumHeight(120)
plugin.group_box_dq = QGroupBox("Data Quality Flags")
plugin.group_box_dq_layout = QVBoxLayout(plugin.group_box_dq)
plugin.group_box_dq_layout.setContentsMargins(10, 10, 10, 10)
plugin.tree_widget_dq = QTreeWidget()
plugin.tree_widget_dq.setColumnCount(3)
plugin.tree_widget_dq.headerItem().setText(0, "Bit")
plugin.tree_widget_dq.headerItem().setText(1, "Name")
plugin.tree_widget_dq.headerItem().setText(2, "Description")
plugin.group_box_dq_layout.addWidget(plugin.tree_widget_dq)
plugin.layout_vertical.addWidget(plugin.group_box)
plugin.layout_vertical.addWidget(plugin.group_box_dq)
def _make_tree_widget(self):
"""
Make a tree widget for displaying algorithms in their categories.
:return: A QTreeWidget
"""
tree = QTreeWidget(self)
tree.setColumnCount(1)
tree.setHeaderHidden(True)
tree.itemSelectionChanged.connect(self._on_tree_selection_changed)
return tree
def connection_changed(self, connected):
build = (self._node is None) and (self._connected != connected
and connected is True)
super(DebugTree, self).connection_changed(connected)
if not build:
return
self._node = nodeFromAddress(self.channel)
self._path = self.channel
vb = QVBoxLayout()
self.setLayout(vb)
self._tree = QTreeWidget()
vb.addWidget(self._tree)
self._tree.setColumnCount(5)
self._tree.setHeaderLabels(
['Node', 'Mode', 'Type', 'Variable', 'Command', 'Units'])
self._tree.itemExpanded.connect(self._expandCb)
hb = QHBoxLayout()
vb.addLayout(hb)
if self._node.isinstance(pyrogue.Root):
hb.addWidget(
PyDMPushButton(label='Read All',
pressValue=True,
init_channel=self._path + '.ReadAll'))
else:
hb.addWidget(
PyDMPushButton(label='Read Recursive',
pressValue=True,
init_channel=self._path + '.ReadDevice'))
self.setUpdatesEnabled(False)
DebugDev(path=self._path,
top=self,
parent=self._tree,
dev=self._node,
noExpand=False)
self.setUpdatesEnabled(True)
def __init__(self, appdata: CnaData):
QWidget.__init__(self)
self.appdata = appdata
self.last_selected = None
self.metabolite_list = QTreeWidget()
self.metabolite_list.setHeaderLabels(["Id", "Name"])
self.metabolite_list.setSortingEnabled(True)
for m in self.appdata.project.cobra_py_model.metabolites:
self.add_metabolite(m)
self.metabolite_list.setContextMenuPolicy(Qt.CustomContextMenu)
self.metabolite_list.customContextMenuRequested.connect(
self.on_context_menu)
# create context menu
self.pop_menu = QMenu(self.metabolite_list)
in_out_fluxes_action = QAction(
'compute in/out fluxes for this metabolite', self.metabolite_list)
self.pop_menu.addAction(in_out_fluxes_action)
in_out_fluxes_action.triggered.connect(self.emit_in_out_fluxes_action)
self.metabolite_mask = MetabolitesMask(appdata)
self.metabolite_mask.hide()
self.layout = QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.splitter.addWidget(self.metabolite_list)
self.splitter.addWidget(self.metabolite_mask)
self.layout.addWidget(self.splitter)
self.setLayout(self.layout)
self.metabolite_list.currentItemChanged.connect(
self.metabolite_selected)
self.metabolite_mask.metaboliteChanged.connect(
self.handle_changed_metabolite)
self.metabolite_mask.jumpToReaction.connect(
self.emit_jump_to_reaction)
def __init__(self, parent: MainWindow, renderers: List[Renderer]) -> None:
"""Initialize the Editor."""
super().__init__(parent=parent)
self.renderers = renderers
self.tree_widget = QTreeWidget()
self.tree_widget.setHeaderHidden(True)
self.stacked_widget = QStackedWidget()
self.layout = QHBoxLayout()
self.layout.addWidget(self.tree_widget)
self.layout.addWidget(self.stacked_widget)
def _selection_callback() -> None:
for item in self.tree_widget.selectedItems():
widget_idx = item.data(0, Qt.ItemDataRole.UserRole)
self.stacked_widget.setCurrentIndex(widget_idx)
self.tree_widget.itemSelectionChanged.connect(_selection_callback)
self.setLayout(self.layout)
self.setWindowTitle("Editor")
self.setModal(True)
self.update()
def __init__(self, import_dict, local_dict, viewer, parent=None):
"""
:type import_dict: dict[str, object]
:type local_dict: dict[str, object]
:param import_dict:
:param local_dict:
:param viewer:
"""
super().__init__(parent=parent)
self.setWindowTitle("Import")
self.viewer = viewer()
self.local_viewer = viewer()
self.import_dict = import_dict
self.local_dict = local_dict
conflicts = set(local_dict.keys()) & set(import_dict.keys())
# print(conflicts)
self.list_view = QTreeWidget()
self.list_view.setColumnCount(4)
self.radio_group_list = []
self.checked_num = len(import_dict)
def rename_func(ob_name, new_name_field, rename_radio):
end_reg = re.compile(r"(.*) \((\d+)\)$")
def in_func():
if not rename_radio.isChecked() or str(new_name_field.text()).strip() != "":
return
match = end_reg.match(ob_name)
if match:
new_name_format = match.group(1) + " ({})"
i = int(match.group(2)) + 1
else:
new_name_format = ob_name + " ({})"
i = 1
while new_name_format.format(i) in self.local_dict:
i += 1
new_name_field.setText(new_name_format.format(i))
return in_func
def block_import(radio_btn, name_field):
def inner_func():
text = str(name_field.text()).strip()
if text == "" and radio_btn.isChecked():
self.import_btn.setDisabled(True)
else:
self.import_btn.setEnabled(True)
return inner_func
for name in sorted(import_dict.keys()):
item = QTreeWidgetItem()
item.setText(0, name)
# noinspection PyTypeChecker
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(0, Qt.Checked)
self.list_view.addTopLevelItem(item)
if name in conflicts:
group = QButtonGroup()
overwrite = QRadioButton("Overwrite")
overwrite.setChecked(True)
rename = QRadioButton("Rename")
new_name = QLineEdit()
new_name.textChanged.connect(block_import(rename, new_name))
rename.toggled.connect(block_import(rename, new_name))
overwrite.toggled.connect(block_import(rename, new_name))
rename.toggled.connect(rename_func(name, new_name, rename))
group.addButton(overwrite)
group.addButton(rename)
self.radio_group_list.append(group)
self.list_view.setItemWidget(item, 1, overwrite)
self.list_view.setItemWidget(item, 2, rename)
self.list_view.setItemWidget(item, 3, new_name)
self.import_btn = QPushButton("Import")
self.cancel_btn = QPushButton("Cancel")
self.check_btn = QPushButton("Check all")
self.uncheck_btn = QPushButton("Uncheck all")
self.cancel_btn.clicked.connect(self.close)
self.import_btn.clicked.connect(self.accept)
self.check_btn.clicked.connect(self.check_all)
self.uncheck_btn.clicked.connect(self.uncheck_all)
self.list_view.itemSelectionChanged.connect(self.preview)
self.list_view.itemChanged.connect(self.checked_change)
layout = QVBoxLayout()
info_layout = QHBoxLayout()
info_layout.addWidget(self.list_view, 2)
v1_lay = QVBoxLayout()
v1_lay.addWidget(QLabel("Import:"))
v1_lay.addWidget(self.viewer)
info_layout.addLayout(v1_lay, 1)
# info_layout.addWidget(self.local_viewer, 1)
v2_lay = QVBoxLayout()
v2_lay.addWidget(QLabel("Local:"))
v2_lay.addWidget(self.local_viewer)
info_layout.addLayout(v2_lay, 1)
layout.addLayout(info_layout)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.check_btn)
btn_layout.addWidget(self.uncheck_btn)
btn_layout.addStretch()
btn_layout.addWidget(self.import_btn)
btn_layout.addWidget(self.cancel_btn)
layout.addLayout(btn_layout)
self.setLayout(layout)
def generate_context_menu(self, pos: QPoint):
"""
Generate a context menu for contextMenuEvent
Parameters
----------
pos : QPoint
The point where the context menu was requested
"""
model_menu = QMenu()
skip_text = "skip me"
# Add filterbox to the context menu
txt_box = QLineEdit(model_menu)
txt_box.setPlaceholderText("Filter")
txt_box.setClearButtonEnabled(True)
txt_box_action = QWidgetAction(model_menu)
txt_box_action.setDefaultWidget(txt_box)
model_menu.addAction(txt_box_action)
# Add result treeview to the context menu
tree_view = QTreeWidget(model_menu)
tree_view.header().close()
tree_view_action = QWidgetAction(model_menu)
tree_view_action.setDefaultWidget(tree_view)
model_menu.addAction(tree_view_action)
top_level_items = {}
for cat in self._scene.registry.categories():
item = QTreeWidgetItem(tree_view)
item.setText(0, cat)
item.setData(0, Qt.UserRole, skip_text)
top_level_items[cat] = item
registry = self._scene.registry
for model, category in registry.registered_models_category_association(
).items():
self.parent = top_level_items[category]
item = QTreeWidgetItem(self.parent)
item.setText(0, model)
item.setData(0, Qt.UserRole, model)
tree_view.expandAll()
def click_handler(item):
model_name = item.data(0, Qt.UserRole)
if model_name == skip_text:
return
type_ = self._scene.registry.create(model_name)
if type_:
node = self._scene.create_node(type_)
pos_view = self.mapToScene(pos)
node.graphics_object.setPos(pos_view)
self._scene.node_placed.emit(node)
else:
logger.debug("Model not found")
model_menu.close()
tree_view.itemClicked.connect(click_handler)
# Setup filtering
def filter_handler(text):
for name, top_lvl_item in top_level_items.items():
for i in range(top_lvl_item.childCount()):
child = top_lvl_item.child(i)
model_name = child.data(0, Qt.UserRole)
child.setHidden(text not in model_name)
txt_box.textChanged.connect(filter_handler)
# make sure the text box gets focus so the user doesn't have to click on it
txt_box.setFocus()
return model_menu
def __init__(self, file_list, calculation_plan, measurement_file_path,
settings, batch_manager):
"""
:param file_list: list of files to proceed
:type file_list: list[str]
:param calculation_plan: calculation plan for this run
:type calculation_plan: CalculationPlan
:param measurement_file_path: path to measurement result file
:type measurement_file_path: str
:param settings: settings object
:type settings: PartSettings
:type batch_manager: CalculationManager
"""
super().__init__()
self.setWindowTitle("Calculation start")
self.file_list = file_list
self.calculation_plan = calculation_plan
self.measurement_file_path = measurement_file_path
self.settings = settings
self.batch_manager = batch_manager
self.info_label = QLabel(
"Information, <i><font color='blue'>warnings</font></i>, "
"<b><font color='red'>errors</font><b>")
self.voxel_size = Spacing("Voxel size", settings.image.spacing,
settings.get("units_value", Units.nm))
all_prefix = os.path.commonprefix(file_list)
if not os.path.exists(all_prefix):
all_prefix = os.path.dirname(all_prefix)
if not os.path.isdir(all_prefix):
all_prefix = os.path.dirname(all_prefix)
self.base_prefix = QLineEdit(all_prefix, self)
self.base_prefix.setReadOnly(True)
self.result_prefix = QLineEdit(all_prefix, self)
self.result_prefix.setReadOnly(True)
self.base_prefix_btn = QPushButton("Choose data prefix")
self.base_prefix_btn.clicked.connect(self.choose_data_prefix)
self.result_prefix_btn = QPushButton("Choose save prefix")
self.result_prefix_btn.clicked.connect(self.choose_result_prefix)
self.sheet_name = QLineEdit("Sheet1")
self.sheet_name.textChanged.connect(self.verify_data)
self.measurement_file_path_view = QLineEdit(measurement_file_path)
self.measurement_file_path_view.setReadOnly(True)
self.mask_path_list = []
self.mask_mapper_list = self.calculation_plan.get_list_file_mask()
mask_file_list = []
for i, el in enumerate(self.mask_mapper_list):
if isinstance(el, MaskFile):
mask_file_list.append((i, el))
mask_path_layout = QGridLayout()
for i, (pos, mask_file) in enumerate(mask_file_list):
if mask_file.name == "":
mask_path_layout.addWidget(
right_label("Path to file {} with mask mapping".format(i +
1)))
else:
mask_path_layout.addWidget(
right_label(
"Path to file {} with mask mapping for name: {}".
format(i + 1, mask_file.name)))
mask_path = QLineEdit(self)
mask_path.setReadOnly(True)
self.mask_path_list.append(mask_path)
set_path = QPushButton("Choose file", self)
set_path.clicked.connect(self.set_mapping_mask(i, pos))
mask_path_layout.addWidget(mask_path, i, 1)
mask_path_layout.addWidget(set_path, i, 2)
self.state_list = np.zeros(
(len(self.file_list), len(self.mask_mapper_list)), dtype=np.uint8)
self.file_list_widget = QTreeWidget()
self.file_list_widget.header().close()
self.execute_btn = QPushButton("Execute")
self.execute_btn.clicked.connect(self.accept)
self.cancel_btn = QPushButton("Cancel")
self.cancel_btn.clicked.connect(self.close)
layout = QGridLayout()
layout.addWidget(self.info_label, 0, 0, 1, 5)
layout.addWidget(self.voxel_size, 1, 0, 1, 5)
layout.addWidget(right_label("Measurement sheet name:"), 3, 3)
layout.addWidget(self.sheet_name, 3, 4)
layout.addWidget(right_label("Measurement file path:"), 2, 3)
layout.addWidget(self.measurement_file_path_view, 2, 4)
layout.addWidget(right_label("Data prefix:"), 2, 0)
layout.addWidget(self.base_prefix, 2, 1)
layout.addWidget(self.base_prefix_btn, 2, 2)
layout.addWidget(right_label("Save prefix:"), 3, 0)
layout.addWidget(self.result_prefix, 3, 1)
layout.addWidget(self.result_prefix_btn, 3, 2)
layout.addLayout(mask_path_layout, 4, 0, 1, 0)
layout.addWidget(self.file_list_widget, 5, 0, 3, 6)
btn_layout = QHBoxLayout()
btn_layout.addWidget(self.execute_btn)
btn_layout.addStretch()
btn_layout.addWidget(self.cancel_btn)
layout.addLayout(btn_layout, 8, 0, 1, 0)
self.setLayout(layout)
self.verify_data()
def __init__(self, *args, **kwargs):
self.active_filename = ""
self._main_view = QMainWindow()
self._main_view.setCentralWidget(QWidget())
self._main_view.centralWidget().hide()
self._editors = QStackedWidget()
self.workflow_process_selector = QComboBox()
self.workflow_process_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.workflow_process_selector.addItem("TomoPy Workflow")
self._workflow = None
self._tomo_workflow = TomographyWorkflow() # Create a workflow
self._workflow = self._tomo_workflow
self._workflow_editor = WorkflowEditor(workflow=self._workflow)
self._workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._active_workflow_executor = QTreeWidget()
self._editors.addWidget(self._workflow_editor)
if hasLTT:
self._alt_workflow = LTTWorkflow()
self.workflow_process_selector.addItem("LTT Workflow")
self._alt_workflow_editor = WorkflowEditor(self._alt_workflow)
self._alt_workflow_editor.sigRunWorkflow.connect(self.run_workflow)
self._editors.addWidget(self._alt_workflow_editor)
self.workflow_process_selector.setCurrentIndex(0)
self.workflow_process_selector.currentIndexChanged.connect(self.active_workflow_changed)
self._active_workflow_widget = QWidget()
self._active_layout = QVBoxLayout()
self._active_layout.addWidget(self.workflow_process_selector)
self._active_layout.addWidget(self._editors)
self._active_layout.addWidget(self._active_workflow_executor)
self._active_workflow_widget.setLayout(self._active_layout)
# self.hdf5_viewer = HDFTreeViewer()
# self.hdf5_viewer.load("/Users/hari/20200521_160002_heartbeat_test.h5")
self.top_controls = QWidget()
self.top_controls_layout = QHBoxLayout()
self.top_controls.setLayout(self.top_controls_layout)
self.top_controls_add_new_selector = QComboBox()
self.top_controls_frequency_selector = QSpinBox()
self.top_controls_frequency_selector.setValue(0)
self.top_controls_add_new_viewer = QPushButton()
self.top_controls_add_new_viewer.setText("Add Viewer")
self.top_controls_add_new_viewer.clicked.connect(self.add_new_viewer_selected)
self.top_controls_preview = QPushButton()
self.top_controls_preview.setText("Preview")
self.top_controls_preview.clicked.connect(self.preview_workflows)
self.top_controls_execute = QPushButton()
self.top_controls_execute.setText("Execute All")
self.top_controls_execute.clicked.connect(self.execute_workflows)
self.top_controls_add_new_selector.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.top_controls_add_new_viewer.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_execute.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_frequency_selector.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.top_controls_layout.addWidget(self.top_controls_add_new_selector)
self.top_controls_layout.addWidget(self.top_controls_add_new_viewer)
self.top_controls_layout.addWidget(self.top_controls_frequency_selector)
self.top_controls_layout.addWidget(self.top_controls_preview)
self.top_controls_layout.addWidget(self.top_controls_execute)
self.top_controls.setLayout(self.top_controls_layout)
self.status_bar = QLabel("None Loaded...")
# Create a layout to organize our widgets
# The first argument (which corresponds to the center widget) is required.
catalog_viewer_layout = GUILayout(self._main_view,
top=self.top_controls,
right=self._active_workflow_widget,
bottom=self.status_bar)
# Create a "View" stage that has the catalog viewer layout
self.stages = {"View": catalog_viewer_layout}
self.active_workflows = []
# For classes derived from GUIPlugin, this super __init__ must occur at end
super(TomographyPlugin, self).__init__(*args, **kwargs)
def __init__(self, parent: ReactionList):
QWidget.__init__(self)
self.parent = parent
self.reaction = None
self.is_valid = True
self.changed = False
self.setAcceptDrops(False)
layout = QVBoxLayout()
l = QHBoxLayout()
self.delete_button = QPushButton("Delete reaction")
self.delete_button.setIcon(QIcon.fromTheme("edit-delete"))
policy = QSizePolicy()
policy.ShrinkFlag = True
self.delete_button.setSizePolicy(policy)
l.addWidget(self.delete_button)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Id:")
self.id = QLineEdit()
l.addWidget(label)
l.addWidget(self.id)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Name:")
self.name = QLineEdit()
l.addWidget(label)
l.addWidget(self.name)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Equation:")
self.equation = QLineEdit()
l.addWidget(label)
l.addWidget(self.equation)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate min:")
self.lower_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.lower_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Rate max:")
self.upper_bound = QLineEdit()
l.addWidget(label)
l.addWidget(self.upper_bound)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Coefficient in obj. function:")
self.coefficent = QLineEdit()
l.addWidget(label)
l.addWidget(self.coefficent)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Gene reaction rule:")
self.gene_reaction_rule = QLineEdit()
l.addWidget(label)
l.addWidget(self.gene_reaction_rule)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Annotations:")
l.addWidget(label)
l2 = QHBoxLayout()
self.annotation = QTableWidget(0, 2)
self.annotation.setHorizontalHeaderLabels(
["key", "value"])
self.annotation.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
l2.addWidget(self.annotation)
self.add_anno = QPushButton("+")
self.add_anno.clicked.connect(self.add_anno_row)
l2.addWidget(self.add_anno)
l.addItem(l2)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Metabolites involved in this reaction:")
l.addWidget(label)
l2 = QHBoxLayout()
self.metabolites = QTreeWidget()
self.metabolites.setHeaderLabels(["Id"])
self.metabolites.setSortingEnabled(True)
l2.addWidget(self.metabolites)
l.addItem(l2)
self.metabolites.itemDoubleClicked.connect(
self.emit_jump_to_metabolite)
layout.addItem(l)
self.jump_list = JumpList(self)
layout.addWidget(self.jump_list)
self.setLayout(layout)
self.delete_button.clicked.connect(self.delete_reaction)
self.throttler = SignalThrottler(500)
self.throttler.triggered.connect(self.reaction_data_changed)
self.id.textEdited.connect(self.throttler.throttle)
self.name.textEdited.connect(self.throttler.throttle)
self.equation.textEdited.connect(self.throttler.throttle)
self.lower_bound.textEdited.connect(self.throttler.throttle)
self.upper_bound.textEdited.connect(self.throttler.throttle)
self.coefficent.textEdited.connect(self.throttler.throttle)
self.gene_reaction_rule.textEdited.connect(self.throttler.throttle)
self.annotation.itemChanged.connect(self.throttler.throttle)
self.validate_mask()
def __init__(self, appdata):
QWidget.__init__(self)
self.appdata = appdata
self.metabolite = None
self.is_valid = True
self.changed = False
self.setAcceptDrops(False)
layout = QVBoxLayout()
l = QHBoxLayout()
label = QLabel("Id:")
self.id = QLineEdit()
l.addWidget(label)
l.addWidget(self.id)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Name:")
self.name = QLineEdit()
l.addWidget(label)
l.addWidget(self.name)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Formula:")
self.formula = QLineEdit()
l.addWidget(label)
l.addWidget(self.formula)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Charge:")
self.charge = QLineEdit()
l.addWidget(label)
l.addWidget(self.charge)
layout.addItem(l)
l = QHBoxLayout()
label = QLabel("Compartment:")
self.compartment = QLineEdit()
l.addWidget(label)
l.addWidget(self.compartment)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Annotations:")
l.addWidget(label)
l2 = QHBoxLayout()
self.annotation = QTableWidget(0, 2)
self.annotation.setHorizontalHeaderLabels(
["key", "value"])
self.annotation.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
l2.addWidget(self.annotation)
self.add_anno = QPushButton("+")
self.add_anno.clicked.connect(self.add_anno_row)
l2.addWidget(self.add_anno)
l.addItem(l2)
layout.addItem(l)
l = QVBoxLayout()
label = QLabel("Reactions using this metabolite:")
l.addWidget(label)
l2 = QHBoxLayout()
self.reactions = QTreeWidget()
self.reactions.setHeaderLabels(["Id"])
self.reactions.setSortingEnabled(True)
l2.addWidget(self.reactions)
l.addItem(l2)
self.reactions.itemDoubleClicked.connect(self.emit_jump_to_reaction)
layout.addItem(l)
self.setLayout(layout)
self.throttler = SignalThrottler(500)
self.throttler.triggered.connect(self.metabolites_data_changed)
self.id.textEdited.connect(self.throttler.throttle)
self.name.textEdited.connect(self.throttler.throttle)
self.formula.textEdited.connect(self.throttler.throttle)
self.charge.textEdited.connect(self.throttler.throttle)
self.compartment.textEdited.connect(self.throttler.throttle)
self.annotation.itemChanged.connect(self.throttler.throttle)
self.validate_mask()
