def _setup_table_widget(self): """ Make a table showing :return: A QTableWidget object which will contain plot widgets """ table_widget = QTableWidget(3, 7, self) table_widget.setVerticalHeaderLabels(['u1', 'u2', 'u3']) col_headers = [ 'a*', 'b*', 'c*' ] if self.frame == SpecialCoordinateSystem.HKL else ['Qx', 'Qy', 'Qz'] col_headers.extend(['start', 'stop', 'nbins', 'step']) table_widget.setHorizontalHeaderLabels(col_headers) table_widget.setFixedHeight( table_widget.verticalHeader().defaultSectionSize() * (table_widget.rowCount() + 1)) # +1 to include headers for icol in range(table_widget.columnCount()): table_widget.setColumnWidth(icol, 50) table_widget.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) table_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.table = table_widget self.layout.addWidget(self.table)
class PMGTableShow(BaseExtendedWidget): default_bg = QTableWidgetItem().background() default_fg = QTableWidgetItem().foreground() def __init__(self, layout_dir: str, title: List[str], initial_value: List[List[Union[int, float, str]]], size_restricted=False, header_adaption_h=False, header_adaption_v=False, background_color: List[List[Union[str]]] = None, foreground_color: List[List[Union[str]]] = None): super().__init__(layout_dir=layout_dir) self.maximum_rows = 100 self.size_restricted = size_restricted self.header_adaption_h = header_adaption_h self.header_adaption_v = header_adaption_v self.background_color = background_color if background_color is not None else '' self.foreground_color = foreground_color if foreground_color is not None else '' self.char_width = 15 self.on_check_callback = None self.title_list = title entryLayout = QHBoxLayout() entryLayout.setContentsMargins(0, 0, 0, 0) self.ctrl = QTableWidget() self.ctrl.verticalHeader().setVisible(False) self.set_params(size_restricted, header_adaption_h, header_adaption_v) self.ctrl.setColumnCount(len(title)) self.ctrl.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) for i, text in enumerate(title): self.ctrl.setColumnWidth(i, len(text) * self.char_width + 10) self.ctrl.setHorizontalHeaderItem(i, QTableWidgetItem(text)) self.central_layout.addLayout(entryLayout) entryLayout.addWidget(self.ctrl) if initial_value is not None: for sublist in initial_value: assert len(sublist) == len(title), \ 'title is not as long as sublist,%s,%s' % (repr(title), sublist) self.ctrl.setRowCount(len(initial_value)) self.set_value(initial_value) def set_params(self, size_restricted=False, header_adaption_h=False, header_adaption_v=False): self.size_restricted = size_restricted self.header_adaption_h = header_adaption_h self.header_adaption_v = header_adaption_v if header_adaption_h: self.ctrl.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) if header_adaption_v: self.ctrl.verticalHeader().setSectionResizeMode( QHeaderView.Stretch) def check_data(self, value: List[List[Union[int, float, str]]]): for sublist in value: assert len(sublist) == len(self.title_list),\ '%s,%s' % (repr(sublist), repr(self.title_list)) def set_value(self, value: List[List[Union[int, float, str]]]): self.check_data(value) self.ctrl.setRowCount(len(value)) cols = len(value[0]) if isinstance(self.foreground_color, str): fg = [[self.foreground_color for i in range(cols)] for j in range(len(value))] else: fg = self.foreground_color if isinstance(self.background_color, str): bg = [[self.background_color for i in range(cols)] for j in range(len(value))] else: bg = self.background_color for row, row_list in enumerate(value): for col, content in enumerate(row_list): if len(str(content)) * self.char_width > self.ctrl.columnWidth( col): self.ctrl.setColumnWidth( col, len(str(content)) * self.char_width + 10) table_item = QTableWidgetItem(str(content)) table_item.setTextAlignment(Qt.AlignCenter) # 字体颜色(红色) if fg[row][col] == '': table_item.setForeground(self.default_fg) else: table_item.setForeground( QBrush(QColor(*color_str2tup(fg[row][col])))) # 背景颜色(红色) if bg[row][col] == '': table_item.setBackground(self.default_bg) else: table_item.setBackground( QBrush(QColor(*color_str2tup(bg[row][col])))) self.ctrl.setItem(row, col, table_item) if self.size_restricted: if self.header_adaption_h: self.ctrl.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) scrollbar_area_width = 0 else: self.ctrl.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) scrollbar_area_width = 10 self.ctrl.setMaximumHeight((self.ctrl.rowCount() + 1) * 30 + scrollbar_area_width) self.setMaximumHeight((self.ctrl.rowCount() + 1) * 30 + scrollbar_area_width) def alert(self, alert_level: int): self.ctrl.alert(alert_level) def add_row(self, row: List): assert len(row) == self.ctrl.columnCount() rc = self.ctrl.rowCount() self.ctrl.setRowCount(rc + 1) for i, val in enumerate(row): self.ctrl.setItem(rc, i, QTableWidgetItem(str(val))) if self.ctrl.rowCount() > self.maximum_rows: self.ctrl.removeRow(0)
class GroupsPostView(QDialog): """ +------------------------+ | Groups : Post/Delete | +------------------------+ | | | check1 Name1 | | check2 Name2 | | check3 Name3 | | | | SetAsMain | | Apply OK Close | +------------------------+ """ def __init__(self, data, win_parent=None): self.win_parent = win_parent #Init the base class groups = data['groups'] inames = data['inames'] self.imain = data['imain'] self.names = [group.name for group in groups] self.white = (255, 255, 255) self.light_grey = (211, 211, 211) self.inames = inames self.shown_set = data['shown'] self.deleted_groups = set() #self.inames = argsort(self.names) #print('inames =', inames) anames = array(self.names) for iname, name in enumerate(anames[self.inames]): print('name[%s] = %r' % (iname, name)) # ignore these... #self._default_name = data['name'] #self._default_coords = data['coords'] #self._default_elements = data['elements'] #self._default_color = data['color'] #self.coords_pound = data['coords_pound'] #self.elements_pound = data['elements_pound'] #self._default_is_discrete = data['is_discrete'] self.out_data = data QDialog.__init__(self, win_parent) #self.setupUi(self) self.setWindowTitle('Groups: Post/View') self.create_widgets() self.create_layout() self.set_connections() #self.show() def create_widgets(self): # main/delete/supergroup self.set_as_main_button = QPushButton("Set As Main") self.create_super_group_button = QPushButton("Create Super Group") self.delete_groups_button = QPushButton("Delete Groups") self.revert_groups_button = QPushButton("Revert Groups") self.show_groups_button = QPushButton("Show Groups") self.hide_groups_button = QPushButton("Hide Groups") # closing self.apply_button = QPushButton("Apply") self.ok_button = QPushButton("OK") self.cancel_button = QPushButton("Cancel") #table self.table = QTableWidget() self.checks = [] self.names_text = [] bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) bold.setWeight(75) anames = array(self.names) for iname, name in enumerate(anames[self.inames]): check = QTableWidgetItem() check.setCheckState(False) # TODO: create right click menu ??? name_text = QTableWidgetItem(str(name)) if iname == self.imain: name_text.setFont(bold) self.shown_set.add(iname) check.setCheckState(2) name_text.setBackground(QtGui.QColor(*self.light_grey)) elif iname in self.shown_set: name_text.setBackground(QtGui.QColor(*self.light_grey)) self.checks.append(check) self.names_text.append(name_text) def create_layout(self): nrows = len(self.names) table = self.table table.setRowCount(nrows) table.setColumnCount(2) headers = [QString('Operate On'), QString('Name')] table.setHorizontalHeaderLabels(headers) header = table.horizontalHeader() header.setStretchLastSection(True) #table.setAlternatingRowColors(True) #header = table.verticalHeader() #header.setStretchLastSection(True) #table.resize(400, 250) #heighti = table.rowHeight(0) #total_height = nrows * heighti #table.setMaximumHeight(total_height) #table.resize(total_height, None) #for iname, name in enumerate(self.names[self.inames]): #print('name[%s] = %r' % (iname, name)) for iname in self.inames: check = self.checks[iname] name_text = self.names_text[iname] # row, col, value table.setItem(iname, 0, check) table.setItem(iname, 1, name_text) table.resizeRowsToContents() #table.horizontalHeaderItem(1).setTextAlignment(QtCore.AlignHCenter) #= QVBoxLayout() ok_cancel_box = QHBoxLayout() ok_cancel_box.addWidget(self.apply_button) ok_cancel_box.addWidget(self.ok_button) ok_cancel_box.addWidget(self.cancel_button) vbox = QVBoxLayout() vbox.addWidget(table) vbox.addWidget(self.set_as_main_button) #vbox.addWidget(self.create_super_group_button) vbox.addStretch() vbox.addWidget(self.show_groups_button) vbox.addWidget(self.hide_groups_button) vbox.addStretch() vbox.addWidget(self.delete_groups_button) vbox.addWidget(self.revert_groups_button) vbox.addStretch() vbox.addStretch() vbox.addLayout(ok_cancel_box) self.setLayout(vbox) def set_connections(self): """creates the actions for the menu""" self.set_as_main_button.clicked.connect(self.on_set_as_main) self.delete_groups_button.clicked.connect(self.on_delete_groups) self.revert_groups_button.clicked.connect(self.on_revert_groups) self.show_groups_button.clicked.connect(self.on_show_groups) self.hide_groups_button.clicked.connect(self.on_hide_groups) self.create_super_group_button.clicked.connect( self.on_create_super_group) self.apply_button.clicked.connect(self.on_apply) self.ok_button.clicked.connect(self.on_ok) self.cancel_button.clicked.connect(self.on_cancel) def closeEvent(self, event): event.accept() @property def nrows(self): return self.table.rowCount() def on_hide_groups(self): self._set_highlight(self.white) def on_show_groups(self): self._set_highlight(self.light_grey) def _set_highlight(self, color): for irow in range(self.nrows): check = self.checks[irow] is_checked = check.checkState() # 0 - unchecked # 1 - partially checked (invalid) # 2 - checked if is_checked: name_text = self.names_text[irow] name_text.setBackground(QtGui.QColor(*color)) def on_delete_groups(self): for irow in range(self.nrows): check = self.checks[irow] is_checked = check.checkState() # 0 - unchecked # 1 - partially checked (invalid) # 2 - checked if irow == 0 and is_checked: # TODO: change this to a log print('error deleting group ALL...change this to a log') #self.window_parent.log return if is_checked: self.table.hideRow(irow) self.deleted_groups.add(irow) check.setCheckState(0) if self.imain > 0 and self.shown_set == set([0]): bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) self.imain = 0 irow = 0 check = self.checks[irow] name_text = self.names_texts[irow] name_text.setFont(bold) name_text.setBackground(QtGui.QColor(*self.light_grey)) def on_revert_groups(self): for irow in range(self.nrows): self.table.showRow(irow) self.deleted_groups = set() def on_create_super_group(self): inames = [ iname for iname, check in enumerate(self.checks) if bool(check.checkState()) ] if not len(inames): # TODO: add logging print('nothing is checked...') return if inames[0] == 0: # TODO: add logging print("cannot include 'ALL' in supergroup...") return name = 'SuperGroup' # popup gui and get a name irow = self.table.rowCount() self.table.insertRow(irow) check = QTableWidgetItem() check.setCheckState(False) name_text = QTableWidgetItem(str(name)) self.names.extend(name) self.names_text.append(name_text) self.checks.append(check) self.table.setItem(irow, 0, check) self.table.setItem(irow, 1, name_text) def on_set_as_main(self): bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) normal = QtGui.QFont() normal.setBold(False) normal.setItalic(False) imain = None imain_set = False for irow in range(self.nrows): check = self.checks[irow] name_text = self.names_text[irow] is_checked = check.checkState() # 0 - unchecked # 1 - partially checked (invalid) # 2 - checked if is_checked and not imain_set: # TODO: change this to a log #self.window_parent.log imain_set = True imain = irow name_text.setFont(bold) name_text.setBackground(QtGui.QColor(*self.light_grey)) self.shown_set.add(irow) elif irow == self.imain: name_text.setFont(normal) if irow == 0: name_text.setBackground(QtGui.QColor(*self.white)) if irow in self.shown_set: self.shown_set.remove(irow) elif imain == 0: name_text.setBackground(QtGui.QColor(*self.white)) self.shown_set.remove(imain) self.imain = imain def get_main_group(self): return self.imain def get_shown_group(self): return self.shown_set def get_deleted_groups(self): return self.deleted_groups def on_validate(self): flag0 = flag1 = flag2 = True main_group_id = self.get_main_group() shown_groups_ids = self.get_shown_group() deleted_group_ids = self.get_deleted_groups() if flag0 and flag1 and flag2: self.out_data['imain'] = main_group_id self.out_data['shown'] = shown_groups_ids self.out_data['remove'] = deleted_group_ids self.out_data['clicked_ok'] = True return True return False def on_apply(self): passed = self.on_validate() if passed: self.win_parent.on_post_group(self.out_data) def on_ok(self): passed = self.on_validate() if passed: self.close() #self.destroy() def on_cancel(self): self.close()
class CameraWindow(PyDialog): """defines the CameraWindow class""" def __init__(self, data, win_parent=None): """ +--------+ | Camera | +--------+---------------+ | Camera Name | | +-------------------+ | | | | | | | | | | | | | | | | | | | | | | +-------------------+ | | | | Name xxx Save | | Delete Set | | | | Apply OK Cancel | +--------+---------------+ """ PyDialog.__init__(self, data, win_parent) self.setWindowTitle('Camera Views') #self.setWindowIcon(view_icon) self._default_name = 'Camera' self.out_data['clicked_ok'] = False self.cameras = deepcopy(data['cameras']) self.names = sorted(self.cameras.keys()) self.name = QLabel("Name:") self.name_edit = QLineEdit(str(self._default_name)) self.delete_button = QPushButton("Delete") self.set_button = QPushButton("Set") self.save_button = QPushButton("Save") # closing self.apply_button = QPushButton("Apply") self.close_button = QPushButton("Close") self.cancel_button = QPushButton("Cancel") self.table = QTableWidget() names_text = [] for name in self.names: name_text = QTableWidgetItem(str(name)) names_text.append(name_text) self.create_layout(names_text) self.set_connections() def create_layout(self, names_text): nrows = len(self.names) table = self.table table.setRowCount(nrows) table.setColumnCount(1) headers = ['Camera Name'] table.setHorizontalHeaderLabels(headers) header = table.horizontalHeader() header.setStretchLastSection(True) for iname, name_text in enumerate(names_text): # row, col, value table.setItem(iname, 0, name_text) table.resizeRowsToContents() ok_cancel_box = QHBoxLayout() ok_cancel_box.addWidget(self.apply_button) ok_cancel_box.addWidget(self.close_button) ok_cancel_box.addWidget(self.cancel_button) grid = QGridLayout() irow = 0 grid.addWidget(self.name, irow, 0) grid.addWidget(self.name_edit, irow, 1) grid.addWidget(self.save_button, irow, 2) irow += 1 grid.addWidget(self.delete_button, irow, 0) grid.addWidget(self.set_button, irow, 1) irow += 1 vbox = QVBoxLayout() vbox.addWidget(self.table) vbox.addLayout(grid) vbox.addStretch() vbox.addLayout(ok_cancel_box) self.setLayout(vbox) def set_connections(self): """creates the actions for the menu""" #if qt_version == 4: #self.connect(self.ok_button, QtCore.SIGNAL('clicked()'), self.on_ok) self.set_button.clicked.connect(self.on_set) self.save_button.clicked.connect(self.on_save) self.delete_button.clicked.connect(self.on_delete) self.apply_button.clicked.connect(self.on_apply) self.close_button.clicked.connect(self.on_close) self.cancel_button.clicked.connect(self.on_cancel) def on_set(self): objs = self.table.selectedIndexes() if len(objs) == 1: obj = objs[0] irow = obj.row() name = self.names[irow] self.set_camera(name) return True return False def on_save(self): name = str(self.name_edit.text()).strip() if name in self.cameras: return irow = self.nrows if len(name): self.table.insertRow(irow) name_text = QTableWidgetItem(str(name)) self.table.setItem(irow, 0, name_text) self.name_edit.setText('') self.save_camera(name) def set_camera(self, name): camera_data = self.cameras[name] if self.win_parent is None: return self.win_parent.on_set_camera_data(camera_data) def save_camera(self, name): self.names.append(name) if self.win_parent is None: self.cameras[name] = None return self.cameras[name] = self.win_parent.get_camera_data() @property def nrows(self): return self.table.rowCount() def on_delete(self): irows = [] for obj in self.table.selectedIndexes(): irow = obj.row() irows.append(irow) irows.sort() for irow in reversed(irows): self.table.removeRow(irow) name = self.names.pop(irow) del self.cameras[name] #print(' removing irow=%s name=%r' % (irow, name)) def closeEvent(self, event): event.accept() def on_apply(self): passed = self.on_set() #if passed: # self.win_parent.create_plane(self.out_data) return passed def on_close(self): self.out_data['clicked_ok'] = True self.out_data['cameras'] = self.cameras self.close() def on_ok(self): passed = self.on_apply() if passed: name = str(self.name_edit.text()).strip() self.out_data['name'] = name self.out_data['cameras'] = self.cameras self.out_data['clicked_ok'] = True self.close() #self.destroy() def on_cancel(self): self.close()
class MCSDialog(QDialog): """A dialog to perform minimal cut set computation""" def __init__(self, appdata: CnaData, centralwidget): QDialog.__init__(self) self.setWindowTitle("Minimal Cut Sets Computation") self.appdata = appdata self.centralwidget = centralwidget self.eng = appdata.engine self.out = io.StringIO() self.err = io.StringIO() self.layout = QVBoxLayout() l1 = QLabel("Target Region(s)") self.layout.addWidget(l1) s1 = QHBoxLayout() completer = QCompleter( self.appdata.project.cobra_py_model.reactions.list_attr("id"), self) completer.setCaseSensitivity(Qt.CaseInsensitive) self.target_list = QTableWidget(1, 4) self.target_list.setHorizontalHeaderLabels( ["region no", "T", "≥/≤", "t"]) self.target_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.target_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.Fixed) self.target_list.horizontalHeader().resizeSection(0, 100) self.target_list.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed) self.target_list.horizontalHeader().resizeSection(2, 50) item = QLineEdit("1") self.target_list.setCellWidget(0, 0, item) item2 = QLineEdit("") item2.setCompleter(completer) self.target_list.setCellWidget(0, 1, item2) combo = QComboBox(self.target_list) combo.insertItem(1, "≤") combo.insertItem(2, "≥") self.target_list.setCellWidget(0, 2, combo) item = QLineEdit("0") self.target_list.setCellWidget(0, 3, item) s1.addWidget(self.target_list) s11 = QVBoxLayout() self.add_target = QPushButton("+") self.add_target.clicked.connect(self.add_target_region) self.rem_target = QPushButton("-") self.rem_target.clicked.connect(self.rem_target_region) s11.addWidget(self.add_target) s11.addWidget(self.rem_target) s1.addItem(s11) self.layout.addItem(s1) l2 = QLabel("Desired Region(s)") self.layout.addWidget(l2) s2 = QHBoxLayout() self.desired_list = QTableWidget(1, 4) self.desired_list.setHorizontalHeaderLabels( ["region no", "D", "≥/≤", "d"]) self.desired_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.desired_list.horizontalHeader().setSectionResizeMode(0, QHeaderView.Fixed) self.desired_list.horizontalHeader().resizeSection(0, 100) self.desired_list.horizontalHeader().setSectionResizeMode(2, QHeaderView.Fixed) self.desired_list.horizontalHeader().resizeSection(2, 50) item = QLineEdit("1") self.desired_list.setCellWidget(0, 0, item) item2 = QLineEdit("") item2.setCompleter(completer) self.desired_list.setCellWidget(0, 1, item2) combo = QComboBox(self.desired_list) combo.insertItem(1, "≤") combo.insertItem(2, "≥") self.desired_list.setCellWidget(0, 2, combo) item = QLineEdit("0") self.desired_list.setCellWidget(0, 3, item) s2.addWidget(self.desired_list) s21 = QVBoxLayout() self.add_desire = QPushButton("+") self.add_desire.clicked.connect(self.add_desired_region) self.rem_desire = QPushButton("-") self.rem_desire.clicked.connect(self.rem_desired_region) s21.addWidget(self.add_desire) s21.addWidget(self.rem_desire) s2.addItem(s21) self.layout.addItem(s2) s3 = QHBoxLayout() sgx = QVBoxLayout() self.gen_kos = QCheckBox("Gene KOs") self.exclude_boundary = QCheckBox( "Exclude boundary\nreactions as cuts") sg1 = QHBoxLayout() s31 = QVBoxLayout() l = QLabel("Max. Solutions") s31.addWidget(l) l = QLabel("Max. Size") s31.addWidget(l) l = QLabel("Time Limit [sec]") s31.addWidget(l) sg1.addItem(s31) s32 = QVBoxLayout() self.max_solu = QLineEdit("inf") self.max_solu.setMaximumWidth(50) s32.addWidget(self.max_solu) self.max_size = QLineEdit("7") self.max_size.setMaximumWidth(50) s32.addWidget(self.max_size) self.time_limit = QLineEdit("inf") self.time_limit.setMaximumWidth(50) s32.addWidget(self.time_limit) sg1.addItem(s32) sgx.addWidget(self.gen_kos) sgx.addWidget(self.exclude_boundary) sgx.addItem(sg1) s3.addItem(sgx) g3 = QGroupBox("Solver") s33 = QVBoxLayout() self.bg1 = QButtonGroup() optlang_solver_name = interface_to_str( appdata.project.cobra_py_model.problem) self.solver_optlang = QRadioButton(f"{optlang_solver_name} (optlang)") self.solver_optlang.setToolTip( "Uses the solver specified by the current model.") s33.addWidget(self.solver_optlang) self.bg1.addButton(self.solver_optlang) self.solver_cplex_matlab = QRadioButton("CPLEX (MATLAB)") self.solver_cplex_matlab.setToolTip( "Only enabled with MATLAB and CPLEX") s33.addWidget(self.solver_cplex_matlab) self.bg1.addButton(self.solver_cplex_matlab) self.solver_cplex_java = QRadioButton("CPLEX (Octave)") self.solver_cplex_java.setToolTip("Only enabled with Octave and CPLEX") s33.addWidget(self.solver_cplex_java) self.bg1.addButton(self.solver_cplex_java) self.solver_intlinprog = QRadioButton("intlinprog (MATLAB)") self.solver_intlinprog.setToolTip("Only enabled with MATLAB") s33.addWidget(self.solver_intlinprog) self.bg1.addButton(self.solver_intlinprog) self.solver_glpk = QRadioButton("GLPK (Octave/MATLAB)") s33.addWidget(self.solver_glpk) self.bg1.addButton(self.solver_glpk) self.bg1.buttonClicked.connect(self.configure_solver_options) g3.setLayout(s33) s3.addWidget(g3) g4 = QGroupBox("MCS search") s34 = QVBoxLayout() self.bg2 = QButtonGroup() self.any_mcs = QRadioButton("any MCS (fast)") self.any_mcs.setChecked(True) s34.addWidget(self.any_mcs) self.bg2.addButton(self.any_mcs) # Search type: by cardinality only with CPLEX possible self.mcs_by_cardinality = QRadioButton("by cardinality") s34.addWidget(self.mcs_by_cardinality) self.bg2.addButton(self.mcs_by_cardinality) self.smalles_mcs_first = QRadioButton("smallest MCS first") s34.addWidget(self.smalles_mcs_first) self.bg2.addButton(self.smalles_mcs_first) g4.setLayout(s34) s3.addWidget(g4) self.layout.addItem(s3) # Disable incompatible combinations if appdata.selected_engine == 'None': self.solver_optlang.setChecked(True) self.solver_cplex_matlab.setEnabled(False) self.solver_cplex_java.setEnabled(False) self.solver_glpk.setEnabled(False) self.solver_intlinprog.setEnabled(False) if optlang_solver_name != 'cplex': self.mcs_by_cardinality.setEnabled(False) else: self.solver_glpk.setChecked(True) if not self.eng.is_cplex_matlab_ready(): self.solver_cplex_matlab.setEnabled(False) if not self.eng.is_cplex_java_ready(): self.solver_cplex_java.setEnabled(False) if self.appdata.is_matlab_set(): self.solver_cplex_java.setEnabled(False) if not self.appdata.is_matlab_set(): self.solver_cplex_matlab.setEnabled(False) self.solver_intlinprog.setEnabled(False) self.configure_solver_options() s4 = QVBoxLayout() self.consider_scenario = QCheckBox( "Consider constraint given by scenario") s4.addWidget(self.consider_scenario) self.advanced = QCheckBox( "Advanced: Define knockout/addition costs for genes/reactions") self.advanced.setEnabled(False) s4.addWidget(self.advanced) self.layout.addItem(s4) buttons = QHBoxLayout() # self.save = QPushButton("save") # buttons.addWidget(self.save) # self.load = QPushButton("load") # buttons.addWidget(self.load) self.compute_mcs = QPushButton("Compute MCS") buttons.addWidget(self.compute_mcs) # self.compute_mcs2 = QPushButton("Compute MCS2") # buttons.addWidget(self.compute_mcs2) self.cancel = QPushButton("Close") buttons.addWidget(self.cancel) self.layout.addItem(buttons) # max width for buttons self.add_target.setMaximumWidth(20) self.rem_target.setMaximumWidth(20) self.add_desire.setMaximumWidth(20) self.rem_desire.setMaximumWidth(20) self.setLayout(self.layout) # Connecting the signal self.cancel.clicked.connect(self.reject) self.compute_mcs.clicked.connect(self.compute) @Slot() def configure_solver_options(self): optlang_solver_name = interface_to_str( self.appdata.project.cobra_py_model.problem) if self.solver_optlang.isChecked(): self.gen_kos.setChecked(False) self.gen_kos.setEnabled(False) self.exclude_boundary.setEnabled(True) if optlang_solver_name != 'cplex': if self.mcs_by_cardinality.isChecked(): self.mcs_by_cardinality.setChecked(False) self.any_mcs.setChecked(True) self.mcs_by_cardinality.setEnabled(False) self.mcs_by_cardinality.setChecked(False) else: self.gen_kos.setEnabled(True) self.exclude_boundary.setChecked(False) self.exclude_boundary.setEnabled(False) self.mcs_by_cardinality.setEnabled(True) def add_target_region(self): i = self.target_list.rowCount() self.target_list.insertRow(i) completer = QCompleter( self.appdata.project.cobra_py_model.reactions.list_attr("id"), self) completer.setCaseSensitivity(Qt.CaseInsensitive) item = QLineEdit("1") self.target_list.setCellWidget(i, 0, item) item2 = QLineEdit("") item2.setCompleter(completer) self.target_list.setCellWidget(i, 1, item2) combo = QComboBox(self.target_list) combo.insertItem(1, "≤") combo.insertItem(2, "≥") self.target_list.setCellWidget(i, 2, combo) item = QLineEdit("0") self.target_list.setCellWidget(i, 3, item) def add_desired_region(self): i = self.desired_list.rowCount() self.desired_list.insertRow(i) completer = QCompleter( self.appdata.project.cobra_py_model.reactions.list_attr("id"), self) completer.setCaseSensitivity(Qt.CaseInsensitive) item = QLineEdit("1") self.desired_list.setCellWidget(i, 0, item) item2 = QLineEdit("") item2.setCompleter(completer) self.desired_list.setCellWidget(i, 1, item2) combo = QComboBox(self.desired_list) combo.insertItem(1, "≤") combo.insertItem(2, "≥") self.desired_list.setCellWidget(i, 2, combo) item = QLineEdit("0") self.desired_list.setCellWidget(i, 3, item) def rem_target_region(self): i = self.target_list.rowCount() self.target_list.removeRow(i-1) def rem_desired_region(self): i = self.desired_list.rowCount() self.desired_list.removeRow(i-1) def compute(self): if self.solver_optlang.isChecked(): self.compute_optlang() else: self.compute_legacy() def compute_legacy(self): self.setCursor(Qt.BusyCursor) # create CobraModel for matlab with self.appdata.project.cobra_py_model as model: if self.consider_scenario.isChecked(): # integrate scenario into model bounds for r in self.appdata.project.scen_values.keys(): model.reactions.get_by_id( r).bounds = self.appdata.project.scen_values[r] cobra.io.save_matlab_model(model, os.path.join( self.appdata.cna_path, "cobra_model.mat"), varname="cbmodel") self.eng.eval("load('cobra_model.mat')", nargout=0) try: self.eng.eval("cnap = CNAcobra2cna(cbmodel);", nargout=0, stdout=self.out, stderr=self.err) except Exception: output = io.StringIO() traceback.print_exc(file=output) exstr = output.getvalue() print(exstr) QMessageBox.warning(self, 'Unknown exception occured!', exstr+'\nPlease report the problem to:\n\ \nhttps://github.com/cnapy-org/CNApy/issues') return self.eng.eval("genes = [];", nargout=0, stdout=self.out, stderr=self.err) cmd = "maxSolutions = " + str(float(self.max_solu.text())) + ";" self.eng.eval(cmd, nargout=0, stdout=self.out, stderr=self.err) cmd = "maxSize = " + str(int(self.max_size.text())) + ";" self.eng.eval(cmd, nargout=0, stdout=self.out, stderr=self.err) cmd = "milp_time_limit = " + str(float(self.time_limit.text())) + ";" self.eng.eval(cmd, nargout=0, stdout=self.out, stderr=self.err) if self.gen_kos.isChecked(): self.eng.eval("gKOs = 1;", nargout=0) else: self.eng.eval("gKOs = 0;", nargout=0) if self.advanced.isChecked(): self.eng.eval("advanced_on = 1;", nargout=0) else: self.eng.eval("advanced_on = 0;", nargout=0) if self.solver_intlinprog.isChecked(): self.eng.eval("solver = 'intlinprog';", nargout=0) if self.solver_cplex_java.isChecked(): self.eng.eval("solver = 'java_cplex_new';", nargout=0) if self.solver_cplex_matlab.isChecked(): self.eng.eval("solver = 'matlab_cplex';", nargout=0) if self.solver_glpk.isChecked(): self.eng.eval("solver = 'glpk';", nargout=0) if self.any_mcs.isChecked(): self.eng.eval("mcs_search_mode = 'search_1';", nargout=0) elif self.mcs_by_cardinality.isChecked(): self.eng.eval("mcs_search_mode = 'search_2';", nargout=0) elif self.smalles_mcs_first.isChecked(): self.eng.eval("mcs_search_mode = 'search_3';", nargout=0) rows = self.target_list.rowCount() for i in range(0, rows): p1 = self.target_list.cellWidget(i, 0).text() p2 = self.target_list.cellWidget(i, 1).text() if self.target_list.cellWidget(i, 2).currentText() == '≤': p3 = "<=" else: p3 = ">=" p4 = self.target_list.cellWidget(i, 3).text() cmd = "dg_T = {[" + p1+"], '" + p2 + \ "', '" + p3 + "', [" + p4 + "']};" self.eng.eval(cmd, nargout=0, stdout=self.out, stderr=self.err) rows = self.desired_list.rowCount() for i in range(0, rows): p1 = self.desired_list.cellWidget(i, 0).text() p2 = self.desired_list.cellWidget(i, 1).text() if self.desired_list.cellWidget(i, 2).currentText() == '≤': p3 = "<=" else: p3 = ">=" p4 = self.desired_list.cellWidget(i, 3).text() cmd = "dg_D = {[" + p1+"], '" + p2 + \ "', '" + p3 + "', [" + p4 + "']};" self.eng.eval(cmd, nargout=0) # get some data self.eng.eval("reac_id = cellstr(cnap.reacID).';", nargout=0, stdout=self.out, stderr=self.err) mcs = [] values = [] reactions = [] reac_id = [] if self.appdata.is_matlab_set(): reac_id = self.eng.workspace['reac_id'] try: self.eng.eval("[mcs] = cnapy_compute_mcs(cnap, genes, maxSolutions, maxSize, milp_time_limit, gKOs, advanced_on, solver, mcs_search_mode, dg_T,dg_D);", nargout=0) except Exception: output = io.StringIO() traceback.print_exc(file=output) exstr = output.getvalue() print(exstr) QMessageBox.warning(self, 'Unknown exception occured!', exstr+'\nPlease report the problem to:\n\ \nhttps://github.com/cnapy-org/CNApy/issues') return else: self.eng.eval("[reaction, mcs, value] = find(mcs);", nargout=0, stdout=self.out, stderr=self.err) reactions = self.eng.workspace['reaction'] mcs = self.eng.workspace['mcs'] values = self.eng.workspace['value'] elif self.appdata.is_octave_ready(): reac_id = self.eng.pull('reac_id') reac_id = reac_id[0] try: self.eng.eval("[mcs] = cnapy_compute_mcs(cnap, genes, maxSolutions, maxSize, milp_time_limit, gKOs, advanced_on, solver, mcs_search_mode, dg_T,dg_D);", nargout=0) except Exception: output = io.StringIO() traceback.print_exc(file=output) exstr = output.getvalue() print(exstr) QMessageBox.warning(self, 'Unknown exception occured!', exstr+'\nPlease report the problem to:\n\ \nhttps://github.com/cnapy-org/CNApy/issues') return else: self.eng.eval("[reaction, mcs, value] = find(mcs);", nargout=0, stdout=self.out, stderr=self.err) reactions = self.eng.pull('reaction') mcs = self.eng.pull('mcs') values = self.eng.pull('value') if len(mcs) == 0: QMessageBox.information(self, 'No cut sets', 'Cut sets have not been calculated or do not exist.') else: last_mcs = 1 omcs = [] current_mcs = {} for i in range(0, len(reactions)): reacid = int(reactions[i][0]) reaction = reac_id[reacid-1] c_mcs = int(mcs[i][0]) c_value = int(values[i][0]) if c_value == -1: # -1 stands for removed which is 0 in the ui c_value = 0 if c_mcs > last_mcs: omcs.append(current_mcs) last_mcs = c_mcs current_mcs = {} current_mcs[reaction] = c_value omcs.append(current_mcs) self.appdata.project.modes = omcs self.centralwidget.mode_navigator.current = 0 QMessageBox.information(self, 'Cut sets found', str(len(omcs))+' Cut sets have been calculated.') self.centralwidget.update_mode() self.centralwidget.mode_navigator.title.setText("MCS Navigation") self.setCursor(Qt.ArrowCursor) def compute_optlang(self): self.setCursor(Qt.BusyCursor) max_mcs_num = float(self.max_solu.text()) max_mcs_size = int(self.max_size.text()) timeout = float(self.time_limit.text()) if timeout is float('inf'): timeout = None # if self.gen_kos.isChecked(): # self.eng.eval("gKOs = 1;", nargout=0) # else: # self.eng.eval("gKOs = 0;", nargout=0) # if self.advanced.isChecked(): # self.eng.eval("advanced_on = 1;", nargout=0) # else: # self.eng.eval("advanced_on = 0;", nargout=0) if self.smalles_mcs_first.isChecked(): enum_method = 1 elif self.mcs_by_cardinality.isChecked(): enum_method = 2 elif self.any_mcs.isChecked(): enum_method = 3 with self.appdata.project.cobra_py_model as model: if self.consider_scenario.isChecked(): # integrate scenario into model bounds for r in self.appdata.project.scen_values.keys(): model.reactions.get_by_id( r).bounds = self.appdata.project.scen_values[r] reac_id = model.reactions.list_attr("id") reac_id_symbols = cMCS_enumerator.get_reac_id_symbols(reac_id) rows = self.target_list.rowCount() targets = dict() for i in range(0, rows): p1 = self.target_list.cellWidget(i, 0).text() p2 = self.target_list.cellWidget(i, 1).text() if len(p1) > 0 and len(p2) > 0: if self.target_list.cellWidget(i, 2).currentText() == '≤': p3 = "<=" else: p3 = ">=" p4 = float(self.target_list.cellWidget(i, 3).text()) targets.setdefault(p1, []).append((p2, p3, p4)) targets = list(targets.values()) targets = [cMCS_enumerator.relations2leq_matrix(cMCS_enumerator.parse_relations( t, reac_id_symbols=reac_id_symbols), reac_id) for t in targets] rows = self.desired_list.rowCount() desired = dict() for i in range(0, rows): p1 = self.desired_list.cellWidget(i, 0).text() p2 = self.desired_list.cellWidget(i, 1).text() if len(p1) > 0 and len(p2) > 0: if self.desired_list.cellWidget(i, 2).currentText() == '≤': p3 = "<=" else: p3 = ">=" p4 = float(self.desired_list.cellWidget(i, 3).text()) desired.setdefault(p1, []).append((p2, p3, p4)) desired = list(desired.values()) desired = [cMCS_enumerator.relations2leq_matrix(cMCS_enumerator.parse_relations( d, reac_id_symbols=reac_id_symbols), reac_id) for d in desired] try: mcs = cMCS_enumerator.compute_mcs(model, targets=targets, desired=desired, enum_method=enum_method, max_mcs_size=max_mcs_size, max_mcs_num=max_mcs_num, timeout=timeout, exclude_boundary_reactions_as_cuts=self.exclude_boundary.isChecked()) except cMCS_enumerator.InfeasibleRegion as e: QMessageBox.warning(self, 'Cannot calculate MCS', str(e)) return targets, desired except Exception: output = io.StringIO() traceback.print_exc(file=output) exstr = output.getvalue() print(exstr) QMessageBox.warning(self, 'An exception has occured!', exstr+'\nPlease report the problem to:\n\ \nhttps://github.com/cnapy-org/CNApy/issues') return targets, desired finally: self.setCursor(Qt.ArrowCursor) if len(mcs) == 0: QMessageBox.information(self, 'No cut sets', 'Cut sets have not been calculated or do not exist.') return targets, desired omcs = [{reac_id[i]: 0 for i in m} for m in mcs] self.appdata.project.modes = omcs self.centralwidget.mode_navigator.current = 0 QMessageBox.information(self, 'Cut sets found', str(len(omcs))+' Cut sets have been calculated.') self.centralwidget.update_mode() self.centralwidget.mode_navigator.title.setText("MCS Navigation")
class Extension2ReaderTable(QWidget): """Table showing extension to reader mappings with removal button. Widget presented in preferences-plugin dialog.""" valueChanged = Signal(int) def __init__(self, parent=None): super().__init__(parent=parent) self._table = QTableWidget() self._table.setShowGrid(False) self._populate_table() layout = QVBoxLayout() layout.addWidget(self._table) self.setLayout(layout) def _populate_table(self): """Add row for each extension to reader mapping in settings""" self._extension_col = 0 self._reader_col = 1 header_strs = [trans._('Extension'), trans._('Reader Plugin')] self._table.setColumnCount(2) self._table.setColumnWidth(self._extension_col, 100) self._table.setColumnWidth(self._reader_col, 150) self._table.verticalHeader().setVisible(False) self._table.setMinimumHeight(120) extension2reader = get_settings().plugins.extension2reader if len(extension2reader) > 0: self._table.setRowCount(len(extension2reader)) self._table.horizontalHeader().setStretchLastSection(True) self._table.horizontalHeader().setStyleSheet( 'border-bottom: 2px solid white;') self._table.setHorizontalHeaderLabels(header_strs) for row, (extension, plugin_name) in enumerate(extension2reader.items()): item = QTableWidgetItem(extension) item.setFlags(Qt.NoItemFlags) self._table.setItem(row, self._extension_col, item) plugin_widg = QWidget() # need object name to easily find row plugin_widg.setObjectName(f'{extension}') plugin_widg.setLayout(QHBoxLayout()) plugin_widg.layout().setContentsMargins(0, 0, 0, 0) plugin_label = QLabel(plugin_name) # need object name to easily work out which button was clicked remove_btn = QPushButton('x', objectName=f'{extension}') remove_btn.setFixedWidth(30) remove_btn.setStyleSheet('margin: 4px;') remove_btn.setToolTip( trans._('Remove this extension to reader association')) remove_btn.clicked.connect(self._remove_extension_assignment) plugin_widg.layout().addWidget(plugin_label) plugin_widg.layout().addWidget(remove_btn) self._table.setCellWidget(row, self._reader_col, plugin_widg) else: # Display that there are no extensions with reader associations self._table.setRowCount(1) self._table.setHorizontalHeaderLabels(header_strs) self._table.setColumnHidden(self._reader_col, True) self._table.setColumnWidth(self._extension_col, 200) item = QTableWidgetItem(trans._('No extensions found.')) item.setFlags(Qt.NoItemFlags) self._table.setItem(0, 0, item) def _remove_extension_assignment(self, event): """Delete extension to reader mapping setting and remove table row""" extension_to_remove = self.sender().objectName() current_settings = get_settings().plugins.extension2reader # need explicit assignment to new object here for persistence get_settings().plugins.extension2reader = { k: v for k, v in current_settings.items() if k != extension_to_remove } for i in range(self._table.rowCount()): row_widg_name = self._table.cellWidget( i, self._reader_col).objectName() if row_widg_name == extension_to_remove: self._table.removeRow(i) return
class WndManageEmissionLines(SecondaryWindow): signal_selected_element_changed = Signal(str) signal_update_element_selection_list = Signal() signal_update_add_remove_btn_state = Signal(bool, bool) signal_marker_state_changed = Signal(bool) signal_parameters_changed = Signal() def __init__(self, *, gpc, gui_vars): super().__init__() # Global processing classes self.gpc = gpc # Global GUI variables (used for control of GUI state) self.gui_vars = gui_vars # Threshold used for peak removal (displayed in lineedit) self._remove_peak_threshold = self.gpc.get_peak_threshold() self._enable_events = False self._eline_list = [ ] # List of emission lines (used in the line selection combo) self._table_contents = [ ] # Keep a copy of table contents (list of dict) self._selected_eline = "" self.initialize() self._enable_events = True # Marker state is reported by Matplotlib plot in 'line_plot' model def cb(marker_state): self.signal_marker_state_changed.emit(marker_state) self.gpc.set_marker_reporter(cb) self.signal_marker_state_changed.connect( self.slot_marker_state_changed) # Update button states self._update_add_remove_btn_state() self._update_add_edit_userpeak_btn_state() self._update_add_edit_pileup_peak_btn_state() def initialize(self): self.setWindowTitle("PyXRF: Add/Remove Emission Lines") self.resize(600, 600) top_buttons = self._setup_select_elines() self._setup_elines_table() bottom_buttons = self._setup_action_buttons() vbox = QVBoxLayout() # Group of buttons above the table vbox.addLayout(top_buttons) # Tables hbox = QHBoxLayout() hbox.addWidget(self.tbl_elines) vbox.addLayout(hbox) vbox.addLayout(bottom_buttons) self.setLayout(vbox) self._set_tooltips() def _setup_select_elines(self): self.cb_select_all = QCheckBox("All") self.cb_select_all.setChecked(True) self.cb_select_all.toggled.connect(self.cb_select_all_toggled) self.element_selection = ElementSelection() # The following field should switched to 'editable' state from when needed self.le_peak_intensity = LineEditReadOnly() self.pb_add_eline = QPushButton("Add") self.pb_add_eline.clicked.connect(self.pb_add_eline_clicked) self.pb_remove_eline = QPushButton("Remove") self.pb_remove_eline.clicked.connect(self.pb_remove_eline_clicked) self.pb_user_peaks = QPushButton("New User Peak ...") self.pb_user_peaks.clicked.connect(self.pb_user_peaks_clicked) self.pb_pileup_peaks = QPushButton("New Pileup Peak ...") self.pb_pileup_peaks.clicked.connect(self.pb_pileup_peaks_clicked) self.element_selection.signal_current_item_changed.connect( self.element_selection_item_changed) vbox = QVBoxLayout() hbox = QHBoxLayout() hbox.addWidget(self.element_selection) hbox.addWidget(self.le_peak_intensity) hbox.addWidget(self.pb_add_eline) hbox.addWidget(self.pb_remove_eline) vbox.addLayout(hbox) hbox = QHBoxLayout() hbox.addWidget(self.cb_select_all) hbox.addStretch(1) hbox.addWidget(self.pb_user_peaks) hbox.addWidget(self.pb_pileup_peaks) vbox.addLayout(hbox) # Wrap vbox into hbox, because it will be inserted into vbox hbox = QHBoxLayout() hbox.addLayout(vbox) hbox.addStretch(1) return hbox def _setup_elines_table(self): """The table has only functionality necessary to demonstrate how it is going to look. A lot more code is needed to actually make it run.""" self._validator_peak_height = QDoubleValidator() self._validator_peak_height.setBottom(0.01) self.tbl_elines = QTableWidget() self.tbl_elines.setStyleSheet( "QTableWidget::item{color: black;}" "QTableWidget::item:selected{background-color: red;}" "QTableWidget::item:selected{color: white;}") self.tbl_labels = [ "", "Z", "Line", "E, keV", "Peak Int.", "Rel. Int.(%)", "CS" ] self.tbl_cols_editable = ["Peak Int."] self.tbl_value_min = {"Rel. Int.(%)": 0.1} tbl_cols_resize_to_content = ["", "Z", "Line"] self.tbl_elines.setColumnCount(len(self.tbl_labels)) self.tbl_elines.verticalHeader().hide() self.tbl_elines.setHorizontalHeaderLabels(self.tbl_labels) self.tbl_elines.setSelectionBehavior(QTableWidget.SelectRows) self.tbl_elines.setSelectionMode(QTableWidget.SingleSelection) self.tbl_elines.itemSelectionChanged.connect( self.tbl_elines_item_selection_changed) self.tbl_elines.itemChanged.connect(self.tbl_elines_item_changed) header = self.tbl_elines.horizontalHeader() for n, lbl in enumerate(self.tbl_labels): # Set stretching for the columns if lbl in tbl_cols_resize_to_content: header.setSectionResizeMode(n, QHeaderView.ResizeToContents) else: header.setSectionResizeMode(n, QHeaderView.Stretch) # Set alignment for the columns headers (HEADERS only) if n == 0: header.setDefaultAlignment(Qt.AlignCenter) else: header.setDefaultAlignment(Qt.AlignRight) self.cb_sel_list = [] # List of checkboxes def _setup_action_buttons(self): self.pb_remove_rel = QPushButton("Remove Rel.Int.(%) <") self.pb_remove_rel.clicked.connect(self.pb_remove_rel_clicked) self.le_remove_rel = LineEditExtended("") self._validator_le_remove_rel = QDoubleValidator() self._validator_le_remove_rel.setBottom(0.01) # Some small number self._validator_le_remove_rel.setTop(100.0) self.le_remove_rel.setText( self._format_threshold(self._remove_peak_threshold)) self._update_le_remove_rel_state() self.le_remove_rel.textChanged.connect(self.le_remove_rel_text_changed) self.le_remove_rel.editingFinished.connect( self.le_remove_rel_editing_finished) self.pb_remove_unchecked = QPushButton("Remove Unchecked Lines") self.pb_remove_unchecked.clicked.connect( self.pb_remove_unchecked_clicked) hbox = QHBoxLayout() hbox.addWidget(self.pb_remove_rel) hbox.addWidget(self.le_remove_rel) hbox.addStretch(1) hbox.addWidget(self.pb_remove_unchecked) return hbox def _set_tooltips(self): set_tooltip(self.cb_select_all, "<b>Select/Deselect All</b> emission lines in the list") set_tooltip(self.element_selection, "<b>Set active</b> emission line") set_tooltip(self.le_peak_intensity, "Set or modify <b>intensity</b> of the active peak.") set_tooltip(self.pb_add_eline, "<b>Add</b> emission line to the list.") set_tooltip(self.pb_remove_eline, "<b>Remove</b> emission line from the list.") set_tooltip( self.pb_user_peaks, "Open dialog box to add or modify parameters of the <b>user-defined peak</b>" ) set_tooltip( self.pb_pileup_peaks, "Open dialog box to add or modify parameters of the <b>pileup peak</b>" ) set_tooltip(self.tbl_elines, "The list of the selected <b>emission lines</b>") # set_tooltip(self.pb_update, # "Update the internally stored list of selected emission lines " # "and their parameters. This button is <b>deprecated</b>, but still may be " # "needed in some situations. In future releases it will be <b>removed</b> or replaced " # "with 'Accept' button. Substantial changes to the computational code is needed before " # "it happens.") # set_tooltip(self.pb_undo, # "<b>Undo</b> changes to the table of selected emission lines. Doesn't always work.") set_tooltip( self.pb_remove_rel, "<b>Remove emission lines</b> from the list if their relative intensity is less " "then specified threshold.", ) set_tooltip( self.le_remove_rel, "<b>Threshold</b> that controls which emission lines are removed " "when <b>Remove Rel.Int.(%)</b> button is pressed.", ) set_tooltip(self.pb_remove_unchecked, "Remove <b>unchecked</b> emission lines from the list.") def update_widget_state(self, condition=None): # Update the state of the menu bar state = not self.gui_vars["gui_state"]["running_computations"] self.setEnabled(state) # Hide the window if required by the program state state_file_loaded = self.gui_vars["gui_state"]["state_file_loaded"] state_model_exist = self.gui_vars["gui_state"]["state_model_exists"] if not state_file_loaded or not state_model_exist: self.hide() if condition == "tooltips": self._set_tooltips() def fill_eline_table(self, table_contents): self._table_contents = copy.deepcopy(table_contents) self._enable_events = False self.tbl_elines.clearContents() # Clear the list of checkboxes for cb in self.cb_sel_list: cb.stateChanged.connect(self.cb_eline_state_changed) self.cb_sel_list = [] self.tbl_elines.setRowCount(len(table_contents)) for nr, row in enumerate(table_contents): sel_status = row["sel_status"] row_data = [ None, row["z"], row["eline"], row["energy"], row["peak_int"], row["rel_int"], row["cs"] ] for nc, entry in enumerate(row_data): label = self.tbl_labels[nc] # Set alternating background colors for the table rows # Make background for editable items a little brighter brightness = 240 if label in self.tbl_cols_editable else 220 if nr % 2: rgb_bckg = (255, brightness, brightness) # Light-red else: rgb_bckg = (brightness, 255, brightness) # Light-green if nc == 0: item = QWidget() cb = CheckBoxNamed(name=f"{nr}") item_hbox = QHBoxLayout(item) item_hbox.addWidget(cb) item_hbox.setAlignment(Qt.AlignCenter) item_hbox.setContentsMargins(0, 0, 0, 0) css1 = get_background_css(rgb_bckg, widget="QCheckbox", editable=False) css2 = get_background_css(rgb_bckg, widget="QWidget", editable=False) item.setStyleSheet(css2 + css1) cb.setChecked(Qt.Checked if sel_status else Qt.Unchecked) cb.stateChanged.connect(self.cb_eline_state_changed) cb.setStyleSheet("QCheckBox {color: black;}") self.cb_sel_list.append(cb) self.tbl_elines.setCellWidget(nr, nc, item) else: s = None # The case when the value (Rel. Int.) is limited from the bottom # We don't want to print very small numbers here if label in self.tbl_value_min: v = self.tbl_value_min[label] if isinstance(entry, (float, np.float64)) and (entry < v): s = f"<{v:.2f}" if s is None: if isinstance(entry, (float, np.float64)): s = f"{entry:.2f}" if entry else "-" else: s = f"{entry}" if entry else "-" item = QTableWidgetItem(s) item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter) # Set all columns not editable (unless needed) if label not in self.tbl_cols_editable: item.setFlags(item.flags() & ~Qt.ItemIsEditable) brush = QBrush(QColor(*rgb_bckg)) item.setBackground(brush) self.tbl_elines.setItem(nr, nc, item) self._enable_events = True # Update the rest of the widgets self._update_widgets_based_on_table_state() @Slot() def update_widget_data(self): # This is typically a new set of emission lines. Clear the selection both # in the table and in the element selection tool. self.element_selection.set_current_item("") self.tbl_elines.clearSelection() self._set_selected_eline("") # Now update the tables self._update_eline_selection_list() self.update_eline_table() self._update_add_remove_btn_state() def pb_pileup_peaks_clicked(self): data = {} eline = self._selected_eline if self.gpc.get_eline_name_category(eline) == "pileup": logger.error( f"Attempt to add pileup peak '{eline}' while another pileup peak is selected." ) return energy, marker_visible = self.gpc.get_suggested_manual_peak_energy() best_guess = self.gpc.get_guessed_pileup_peak_components(energy=energy, tolerance=0.1) if best_guess is not None: el1, el2, energy = best_guess else: # No peaks were found, enter peaks manually el1, el2, energy = "", "", 0 data["element1"] = el1 data["element2"] = el2 data["energy"] = energy data["range_low"], data[ "range_high"] = self.gpc.get_selected_energy_range() if not marker_visible: # We shouldn't end up here, but this will protect from crashing in case # the button was not disabled (a bug). msg = "Select location of the new peak center (energy)\nby clicking on the plot in 'Fit Model' tab" msgbox = QMessageBox(QMessageBox.Information, "User Input Required", msg, QMessageBox.Ok, parent=self) msgbox.exec() else: dlg = DialogPileupPeakParameters() def func(): def f(e1, e2): try: name = self.gpc.generate_pileup_peak_name(e1, e2) e = self.gpc.get_pileup_peak_energy(name) except Exception: e = 0 return e return f dlg.set_compute_energy_function(func()) dlg.set_parameters(data) if dlg.exec(): print("Pileup peak is added") try: data = dlg.get_parameters() eline1, eline2 = data["element1"], data["element2"] eline = self.gpc.generate_pileup_peak_name(eline1, eline2) self.gpc.add_peak_manual(eline) self.update_eline_table() # Update the table self.tbl_elines_set_selection( eline) # Select new emission line self._set_selected_eline(eline) self._set_fit_status(False) logger.info(f"New pileup peak {eline} was added") except RuntimeError as ex: msg = str(ex) msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() # Reload the table anyway (nothing is going to be selected) self.update_eline_table() def pb_user_peaks_clicked(self): eline = self._selected_eline # If current peak is user_defined peak is_userpeak = self.gpc.get_eline_name_category(eline) == "userpeak" if is_userpeak: data = {} data["enabled"] = True data["name"] = eline data["maxv"] = self.gpc.get_eline_intensity(eline) data["energy"], data[ "fwhm"] = self.gpc.get_current_userpeak_energy_fwhm() dlg = DialogEditUserPeakParameters() dlg.set_parameters(data=data) if dlg.exec(): print("Editing of user defined peak is completed") try: eline = data["name"] data = dlg.get_parameters() self.gpc.update_userpeak(data["name"], data["energy"], data["maxv"], data["fwhm"]) self._set_fit_status(False) logger.info(f"User defined peak {eline} was updated.") except Exception as ex: msg = str(ex) msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() # Reload the table anyway (nothing is going to be selected) self.update_eline_table() else: data = {} data["name"] = self.gpc.get_unused_userpeak_name() data[ "energy"], marker_visible = self.gpc.get_suggested_manual_peak_energy( ) if marker_visible: dlg = DialogNewUserPeak() dlg.set_parameters(data=data) if dlg.exec(): try: eline = data["name"] self.gpc.add_peak_manual(eline) self.update_eline_table() # Update the table self.tbl_elines_set_selection( eline) # Select new emission line self._set_selected_eline(eline) self._set_fit_status(False) logger.info(f"New user defined peak {eline} is added") except RuntimeError as ex: msg = str(ex) msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() # Reload the table anyway (nothing is going to be selected) self.update_eline_table() else: msg = ("Select location of the new peak center (energy)\n" "by clicking on the plot in 'Fit Model' tab") msgbox = QMessageBox(QMessageBox.Information, "User Input Required", msg, QMessageBox.Ok, parent=self) msgbox.exec() @Slot() def pb_add_eline_clicked(self): logger.debug("'Add line' clicked") # It is assumed that this button is active only if an element is selected from the list # of available emission lines. It can't be used to add user-defined peaks or pileup peaks. eline = self._selected_eline if eline: try: self.gpc.add_peak_manual(eline) self.update_eline_table() # Update the table self.tbl_elines_set_selection( eline) # Select new emission line self._set_fit_status(False) except RuntimeError as ex: msg = str(ex) msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() # Reload the table anyway (nothing is going to be selected) self.update_eline_table() @Slot() def pb_remove_eline_clicked(self): logger.debug("'Remove line' clicked") eline = self._selected_eline if eline: # If currently selected line is the emission line (like Ca_K), we want # it to remain selected after it is deleted. This means that nothing is selected # in the table. For other lines, nothing should remain selected. self.tbl_elines.clearSelection() self.gpc.remove_peak_manual(eline) self.update_eline_table() # Update the table if self.gpc.get_eline_name_category(eline) != "eline": eline = "" # This will update widgets self._set_selected_eline(eline) self._set_fit_status(False) def cb_select_all_toggled(self, state): self._enable_events = False eline_list, state_list = [], [] for n_row in range(self.tbl_elines.rowCount()): eline = self._table_contents[n_row]["eline"] # Do not deselect lines in category 'other'. They probably never to be deleted. # They also could be deselected manually. if self.gpc.get_eline_name_category( eline) == "other" and not state: to_check = True else: to_check = state self.cb_sel_list[n_row].setChecked( Qt.Checked if to_check else Qt.Unchecked) eline_list.append(eline) state_list.append(to_check) self.gpc.set_checked_emission_lines(eline_list, state_list) self._set_fit_status(False) self._enable_events = True def cb_eline_state_changed(self, name, state): if self._enable_events: n_row = int(name) state = state == Qt.Checked eline = self._table_contents[n_row]["eline"] self.gpc.set_checked_emission_lines([eline], [state]) self._set_fit_status(False) def tbl_elines_item_changed(self, item): if self._enable_events: n_row, n_col = self.tbl_elines.row(item), self.tbl_elines.column( item) # Value was changed if n_col == 4: text = item.text() eline = self._table_contents[n_row]["eline"] if self._validator_peak_height.validate( text, 0)[0] != QDoubleValidator.Acceptable: val = self._table_contents[n_row]["peak_int"] self._enable_events = False item.setText(f"{val:.2f}") self._enable_events = True self._set_fit_status(False) else: self.gpc.update_eline_peak_height(eline, float(text)) self.update_eline_table() def tbl_elines_item_selection_changed(self): sel_ranges = self.tbl_elines.selectedRanges() # The table is configured to have one or no selected ranges # 'Open' button should be enabled only if a range (row) is selected if sel_ranges: index = sel_ranges[0].topRow() eline = self._table_contents[index]["eline"] if self._enable_events: self._enable_events = False self._set_selected_eline(eline) self.element_selection.set_current_item(eline) self._enable_events = True def tbl_elines_set_selection(self, eline): """ Select the row with emission line `eline` in the table. Deselect everything if the emission line does not exist. """ index = self._get_eline_index_in_table(eline) self.tbl_elines.clearSelection() if index >= 0: self.tbl_elines.selectRow(index) def element_selection_item_changed(self, index, eline): self.signal_selected_element_changed.emit(eline) if self._enable_events: self._enable_events = False self._set_selected_eline(eline) self.tbl_elines_set_selection(eline) self._enable_events = True def pb_remove_rel_clicked(self): try: self.gpc.remove_peaks_below_threshold(self._remove_peak_threshold) except Exception as ex: msg = str(ex) msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() self.update_eline_table() # Update the displayed estimated peak amplitude value 'le_peak_intensity' self._set_selected_eline(self._selected_eline) self._set_fit_status(False) def le_remove_rel_text_changed(self, text): self._update_le_remove_rel_state(text) def le_remove_rel_editing_finished(self): text = self.le_remove_rel.text() if self._validator_le_remove_rel.validate( text, 0)[0] == QDoubleValidator.Acceptable: self._remove_peak_threshold = float(text) else: self.le_remove_rel.setText( self._format_threshold(self._remove_peak_threshold)) def pb_remove_unchecked_clicked(self): try: self.gpc.remove_unchecked_peaks() except Exception as ex: msg = str(ex) msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() # Reload the table self.update_eline_table() # Update the displayed estimated peak amplitude value 'le_peak_intensity' self._set_selected_eline(self._selected_eline) self._set_fit_status(False) def _display_peak_intensity(self, eline): v = self.gpc.get_eline_intensity(eline) s = f"{v:.10g}" if v is not None else "" self.le_peak_intensity.setText(s) def _update_le_remove_rel_state(self, text=None): if text is None: text = self.le_remove_rel.text() state = self._validator_le_remove_rel.validate( text, 0)[0] == QDoubleValidator.Acceptable self.le_remove_rel.setValid(state) self.pb_remove_rel.setEnabled(state) @Slot(str) def slot_selection_item_changed(self, eline): self.element_selection.set_current_item(eline) @Slot(bool) def slot_marker_state_changed(self, state): # If userpeak is selected and plot is clicked (marker is set), then user # should be allowed to add userpeak at a new location. So deselect the userpeak # from the table (if it is selected) logger.debug( f"Vertical marker on the fit plot changed state to {state}.") if state: self._deselect_special_peak_in_table() # Now update state of all buttons self._update_add_remove_btn_state() self._update_add_edit_userpeak_btn_state() self._update_add_edit_pileup_peak_btn_state() def _format_threshold(self, value): return f"{value:.2f}" def _deselect_special_peak_in_table(self): """Deselect userpeak if a userpeak is selected""" if self.gpc.get_eline_name_category( self._selected_eline) in ("userpeak", "pileup"): # Clear all selections self.tbl_elines_set_selection("") self._set_selected_eline("") # We also want to show marker at the new position self.gpc.show_marker_at_current_position() def _update_widgets_based_on_table_state(self): index, eline = self._get_current_index_in_table() if index >= 0: # Selection exists. Update the state of element selection widget. self.element_selection.set_current_item(eline) else: # No selection, update the state based on element selection widget. eline = self._selected_eline self.tbl_elines_set_selection(eline) self._update_add_remove_btn_state(eline) self._update_add_edit_userpeak_btn_state() self._update_add_edit_pileup_peak_btn_state() def _update_eline_selection_list(self): self._eline_list = self.gpc.get_full_eline_list() self.element_selection.set_item_list(self._eline_list) self.signal_update_element_selection_list.emit() @Slot() def update_eline_table(self): """Update table of emission lines without changing anything else""" eline_table = self.gpc.get_selected_eline_table() self.fill_eline_table(eline_table) def _get_eline_index_in_table(self, eline): try: index = [_["eline"] for _ in self._table_contents].index(eline) except ValueError: index = -1 return index def _get_eline_index_in_list(self, eline): try: index = self._eline_list.index(eline) except ValueError: index = -1 return index def _get_current_index_in_table(self): sel_ranges = self.tbl_elines.selectedRanges() # The table is configured to have one or no selected ranges # 'Open' button should be enabled only if a range (row) is selected if sel_ranges: index = sel_ranges[0].topRow() eline = self._table_contents[index]["eline"] else: index, eline = -1, "" return index, eline def _get_current_index_in_list(self): index, eline = self.element_selection.get_current_item() return index, eline def _update_add_remove_btn_state(self, eline=None): if eline is None: index_in_table, eline = self._get_current_index_in_table() index_in_list, eline = self._get_current_index_in_list() else: index_in_table = self._get_eline_index_in_table(eline) index_in_list = self._get_eline_index_in_list(eline) add_enabled, remove_enabled = True, True if index_in_list < 0 and index_in_table < 0: add_enabled, remove_enabled = False, False else: if index_in_table >= 0: if self.gpc.get_eline_name_category(eline) != "other": add_enabled = False else: add_enabled, remove_enabled = False, False else: remove_enabled = False self.pb_add_eline.setEnabled(add_enabled) self.pb_remove_eline.setEnabled(remove_enabled) self.signal_update_add_remove_btn_state.emit(add_enabled, remove_enabled) def _update_add_edit_userpeak_btn_state(self): enabled = True add_peak = True if self.gpc.get_eline_name_category( self._selected_eline) == "userpeak": add_peak = False # Finally check if marker is set (you need it for adding peaks) _, marker_set = self.gpc.get_suggested_manual_peak_energy() if not marker_set and add_peak: enabled = False if add_peak: btn_text = "New User Peak ..." else: btn_text = "Edit User Peak ..." self.pb_user_peaks.setText(btn_text) self.pb_user_peaks.setEnabled(enabled) def _update_add_edit_pileup_peak_btn_state(self): enabled = True if self.gpc.get_eline_name_category(self._selected_eline) == "pileup": enabled = False # Finally check if marker is set (you need it for adding peaks) _, marker_set = self.gpc.get_suggested_manual_peak_energy() # Ignore set marker for userpeaks (marker is used to display location of userpeaks) if self.gpc.get_eline_name_category( self._selected_eline) == "userpeak": marker_set = False if not marker_set: enabled = False self.pb_pileup_peaks.setEnabled(enabled) def _set_selected_eline(self, eline): self._update_add_remove_btn_state(eline) if eline != self._selected_eline: self._selected_eline = eline self.gpc.set_selected_eline(eline) self._display_peak_intensity(eline) else: # Peak intensity may change in some circumstances, so renew the displayed value. self._display_peak_intensity(eline) # Update button states after 'self._selected_eline' is set self._update_add_edit_userpeak_btn_state() self._update_add_edit_pileup_peak_btn_state() def _set_fit_status(self, status): self.gui_vars["gui_state"]["state_model_fit_exists"] = status self.signal_parameters_changed.emit()
class ReactionMask(QWidget): """The input mask for a reaction""" 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 add_anno_row(self): i = self.annotation.rowCount() self.annotation.insertRow(i) self.changed = True def apply(self): try: self.reaction.id = self.id.text() except ValueError: turn_red(self.id) QMessageBox.information( self, 'Invalid id', 'Could not apply changes identifier ' + self.id.text() + ' already used.') else: self.reaction.name = self.name.text() self.reaction.build_reaction_from_string(self.equation.text()) self.reaction.lower_bound = float(self.lower_bound.text()) self.reaction.upper_bound = float(self.upper_bound.text()) self.reaction.objective_coefficient = float(self.coefficent.text()) self.reaction.gene_reaction_rule = self.gene_reaction_rule.text() self.reaction.annotation = {} rows = self.annotation.rowCount() for i in range(0, rows): key = self.annotation.item(i, 0).text() if self.annotation.item(i, 1) is None: value = "" else: value = self.annotation.item(i, 1).text() self.reaction.annotation[key] = value self.changed = False self.reactionChanged.emit(self.reaction) def delete_reaction(self): self.hide() self.reactionDeleted.emit(self.reaction) def validate_id(self): with self.parent.appdata.project.cobra_py_model as model: try: r = cobra.Reaction(id=self.id.text()) model.add_reaction(r) except ValueError: turn_red(self.id) return False else: turn_white(self.id) return True def validate_name(self): with self.parent.appdata.project.cobra_py_model as model: try: r = cobra.Reaction(id="testid", name=self.name.text()) model.add_reaction(r) except ValueError: turn_red(self.name) return False else: turn_white(self.name) return True def validate_equation(self): ok = False test_reaction = cobra.Reaction( "xxxx_cnapy_test_reaction", name="cnapy test reaction") with self.parent.appdata.project.cobra_py_model as model: model.add_reaction(test_reaction) try: eqtxt = self.equation.text().rstrip() if len(eqtxt) > 0 and eqtxt[-1] == '+': turn_red(self.equation) else: test_reaction.build_reaction_from_string(eqtxt) turn_white(self.equation) ok = True except ValueError: turn_red(self.equation) try: test_reaction = self.parent.appdata.project.cobra_py_model.reactions.get_by_id( "xxxx_cnapy_test_reaction") self.parent.appdata.project.cobra_py_model.remove_reactions( [test_reaction], remove_orphans=True) except KeyError: pass return ok def validate_lowerbound(self): try: _x = float(self.lower_bound.text()) except ValueError: turn_red(self.lower_bound) return False else: turn_white(self.lower_bound) return True def validate_upperbound(self): try: _x = float(self.upper_bound.text()) except ValueError: turn_red(self.upper_bound) return False else: turn_white(self.upper_bound) return True def validate_coefficient(self): try: _x = float(self.coefficent.text()) except ValueError: turn_red(self.coefficent) return False else: turn_white(self.coefficent) return True def validate_gene_reaction_rule(self): try: _x = float(self.gene_reaction_rule.text()) except ValueError: turn_red(self.gene_reaction_rule) return False else: turn_white(self.gene_reaction_rule) return True def validate_mask(self): valid_id = self.validate_id() valid_name = self.validate_name() valid_equation = self.validate_equation() valid_lb = self.validate_lowerbound() valid_ub = self.validate_upperbound() valid_coefficient = self.validate_coefficient() if valid_id & valid_name & valid_equation & valid_lb & valid_ub & valid_coefficient: self.is_valid = True else: self.is_valid = False def reaction_data_changed(self): self.changed = True self.validate_mask() if self.is_valid: self.apply() self.update_state() def update_state(self): self.jump_list.clear() for name, m in self.parent.appdata.project.maps.items(): if self.id.text() in m["boxes"]: self.jump_list.add(name) self.metabolites.clear() if self.parent.appdata.project.cobra_py_model.reactions.has_id(self.id.text()): reaction = self.parent.appdata.project.cobra_py_model.reactions.get_by_id( self.id.text()) for m in reaction.metabolites: item = QTreeWidgetItem(self.metabolites) item.setText(0, m.id) item.setText(1, m.name) item.setData(2, 0, m) text = "Id: " + m.id + "\nName: " + m.name item.setToolTip(1, text) def emit_jump_to_map(self, name): self.jumpToMap.emit(name, self.id.text()) def emit_jump_to_metabolite(self, metabolite): self.jumpToMetabolite.emit(str(metabolite.data(2, 0))) jumpToMap = Signal(str, str) jumpToMetabolite = Signal(str) reactionChanged = Signal(cobra.Reaction) reactionDeleted = Signal(cobra.Reaction)
class MeasurementWidget(QWidget): """ :type settings: Settings :type segment: Segment """ def __init__(self, settings: PartSettings, segment=None): super().__init__() self.settings = settings self.segment = segment self.measurements_storage = MeasurementsStorage() self.recalculate_button = QPushButton( "Recalculate and\n replace measurement", self) self.recalculate_button.clicked.connect( self.replace_measurement_result) self.recalculate_append_button = QPushButton( "Recalculate and\n append measurement", self) self.recalculate_append_button.clicked.connect( self.append_measurement_result) self.copy_button = QPushButton("Copy to clipboard", self) self.copy_button.setToolTip( "You cacn copy also with 'Ctrl+C'. To get raw copy copy with 'Ctrl+Shit+C'" ) self.horizontal_measurement_present = QCheckBox( "Horizontal view", self) self.no_header = QCheckBox("No header", self) self.no_units = QCheckBox("No units", self) self.no_units.setChecked(True) self.no_units.clicked.connect(self.refresh_view) self.expand_mode = QCheckBox("Expand", self) self.expand_mode.setToolTip( "Shows results for each component in separate entry") self.file_names = EnumComboBox(FileNamesEnum) self.file_names_label = QLabel("Add file name:") self.file_names.currentIndexChanged.connect(self.refresh_view) self.horizontal_measurement_present.stateChanged.connect( self.refresh_view) self.expand_mode.stateChanged.connect(self.refresh_view) self.copy_button.clicked.connect(self.copy_to_clipboard) self.measurement_type = SearchCombBox(self) # noinspection PyUnresolvedReferences self.measurement_type.currentIndexChanged.connect( self.measurement_profile_selection_changed) self.measurement_type.addItem("<none>") self.measurement_type.addItems( list(sorted(self.settings.measurement_profiles.keys()))) self.measurement_type.setToolTip( 'You can create new measurement profile in advanced window, in tab "Measurement settings"' ) self.channels_chose = ChannelComboBox() self.units_choose = EnumComboBox(Units) self.units_choose.set_value(self.settings.get("units_value", Units.nm)) self.info_field = QTableWidget(self) self.info_field.setColumnCount(3) self.info_field.setHorizontalHeaderLabels(["Name", "Value", "Units"]) self.measurement_add_shift = 0 layout = QVBoxLayout() # layout.addWidget(self.recalculate_button) v_butt_layout = QVBoxLayout() v_butt_layout.setSpacing(1) self.up_butt_layout = QHBoxLayout() self.up_butt_layout.addWidget(self.recalculate_button) self.up_butt_layout.addWidget(self.recalculate_append_button) self.butt_layout = QHBoxLayout() # self.butt_layout.setMargin(0) # self.butt_layout.setSpacing(10) self.butt_layout.addWidget(self.horizontal_measurement_present, 1) self.butt_layout.addWidget(self.no_header, 1) self.butt_layout.addWidget(self.no_units, 1) self.butt_layout.addWidget(self.expand_mode, 1) self.butt_layout.addWidget(self.file_names_label) self.butt_layout.addWidget(self.file_names, 1) self.butt_layout.addWidget(self.copy_button, 2) self.butt_layout2 = QHBoxLayout() self.butt_layout3 = QHBoxLayout() self.butt_layout3.addWidget(QLabel("Channel:")) self.butt_layout3.addWidget(self.channels_chose) self.butt_layout3.addWidget(QLabel("Units:")) self.butt_layout3.addWidget(self.units_choose) # self.butt_layout3.addWidget(QLabel("Noise removal:")) # self.butt_layout3.addWidget(self.noise_removal_method) self.butt_layout3.addWidget(QLabel("Measurement set:")) self.butt_layout3.addWidget(self.measurement_type, 2) v_butt_layout.addLayout(self.up_butt_layout) v_butt_layout.addLayout(self.butt_layout) v_butt_layout.addLayout(self.butt_layout2) v_butt_layout.addLayout(self.butt_layout3) layout.addLayout(v_butt_layout) # layout.addLayout(self.butt_layout) layout.addWidget(self.info_field) self.setLayout(layout) # noinspection PyArgumentList self.clip = QApplication.clipboard() self.settings.image_changed[int].connect(self.image_changed) self.previous_profile = None def check_if_measurement_can_be_calculated(self, name): if name == "<none>": return "<none>" profile: MeasurementProfile = self.settings.measurement_profiles.get( name) if profile.is_any_mask_measurement() and self.settings.mask is None: QMessageBox.information( self, "Need mask", "To use this measurement set please use data with mask loaded", QMessageBox.Ok) self.measurement_type.setCurrentIndex(0) return "<none>" if self.settings.roi is None: QMessageBox.information( self, "Need segmentation", 'Before calculating please create segmentation ("Execute" button)', QMessageBox.Ok, ) self.measurement_type.setCurrentIndex(0) return "<none>" return name def image_changed(self, channels_num): self.channels_chose.change_channels_num(channels_num) def measurement_profile_selection_changed(self, index): text = self.measurement_type.itemText(index) text = self.check_if_measurement_can_be_calculated(text) try: stat = self.settings.measurement_profiles[text] is_mask = stat.is_any_mask_measurement() disable = is_mask and (self.settings.mask is None) except KeyError: disable = True self.recalculate_button.setDisabled(disable) self.recalculate_append_button.setDisabled(disable) if disable: self.recalculate_button.setToolTip( "Measurement profile contains mask measurements when mask is not loaded" ) self.recalculate_append_button.setToolTip( "Measurement profile contains mask measurements when mask is not loaded" ) else: self.recalculate_button.setToolTip("") self.recalculate_append_button.setToolTip("") def copy_to_clipboard(self): s = "" for r in range(self.info_field.rowCount()): for c in range(self.info_field.columnCount()): try: s += str(self.info_field.item(r, c).text()) + "\t" except AttributeError: s += "\t" s = s[:-1] + "\n" # eliminate last '\t' self.clip.setText(s) def replace_measurement_result(self): self.measurements_storage.clear() self.previous_profile = "" self.append_measurement_result() def refresh_view(self): self.measurements_storage.set_expand(self.expand_mode.isChecked()) self.measurements_storage.set_show_units(not self.no_units.isChecked()) self.info_field.clear() save_orientation = self.horizontal_measurement_present.isChecked() columns, rows = self.measurements_storage.get_size(save_orientation) self.info_field.setColumnCount(columns) self.info_field.setRowCount(rows) self.info_field.setHorizontalHeaderLabels( self.measurements_storage.get_header(save_orientation)) self.info_field.setVerticalHeaderLabels( self.measurements_storage.get_rows(save_orientation)) for x in range(rows): for y in range(columns): self.info_field.setItem( x, y, QTableWidgetItem( self.measurements_storage.get_val_as_str( x, y, save_orientation))) if self.file_names.get_value() == FileNamesEnum.No: if save_orientation: self.info_field.removeColumn(0) else: self.info_field.removeRow(0) elif self.file_names.get_value() == FileNamesEnum.Short: if save_orientation: columns = 1 else: rows = 1 for x in range(rows): for y in range(columns): item = self.info_field.item(x, y) item.setText(os.path.basename(item.text())) self.info_field.setEditTriggers(QAbstractItemView.NoEditTriggers) def append_measurement_result(self): try: compute_class = self.settings.measurement_profiles[ self.measurement_type.currentText()] except KeyError: QMessageBox.warning( self, "Measurement profile not found", f"Measurement profile '{self.measurement_type.currentText()}' not found'", ) return if self.settings.roi is None: return units = self.units_choose.get_value() # FIXME find which errors should be displayed as warning # def exception_hook(exception): # QMessageBox.warning(self, "Calculation error", f"Error during calculation: {exception}") for num in compute_class.get_channels_num(): if num >= self.settings.image.channels: QMessageBox.warning( self, "Measurement error", "Cannot calculate this measurement because " f"image do not have channel {num+1}", ) return thread = ExecuteFunctionThread( compute_class.calculate, [ self.settings.image, self.channels_chose.currentIndex(), self.settings.roi_info, units ], ) dial = WaitingDialog( thread, "Measurement calculation") # , exception_hook=exception_hook) dial.exec() stat: MeasurementResult = thread.result if stat is None: return stat.set_filename(self.settings.image_path) self.measurements_storage.add_measurements(stat) self.previous_profile = compute_class.name self.refresh_view() def keyPressEvent(self, e: QKeyEvent): if e.modifiers() & Qt.ControlModifier: selected = self.info_field.selectedRanges() if e.key() == Qt.Key_C: # copy s = "" for r in range(selected[0].topRow(), selected[0].bottomRow() + 1): for c in range(selected[0].leftColumn(), selected[0].rightColumn() + 1): try: s += str(self.info_field.item(r, c).text()) + "\t" except AttributeError: s += "\t" s = s[:-1] + "\n" # eliminate last '\t' self.clip.setText(s) def update_measurement_list(self): self.measurement_type.blockSignals(True) available = list(sorted(self.settings.measurement_profiles.keys())) text = self.measurement_type.currentText() try: index = available.index(text) + 1 except ValueError: index = 0 self.measurement_type.clear() self.measurement_type.addItem("<none>") self.measurement_type.addItems(available) self.measurement_type.setCurrentIndex(index) self.measurement_type.blockSignals(False) def showEvent(self, _): self.update_measurement_list() def event(self, event: QEvent): if event.type() == QEvent.WindowActivate: self.update_measurement_list() return super().event(event) @staticmethod def _move_widgets(widgets_list: List[Tuple[QWidget, int]], layout1: QBoxLayout, layout2: QBoxLayout): for el in widgets_list: layout1.removeWidget(el[0]) layout2.addWidget(el[0], el[1]) def resizeEvent(self, _event: QResizeEvent) -> None: if self.width() < 800 and self.butt_layout2.count() == 0: self._move_widgets( [(self.file_names_label, 1), (self.file_names, 1), (self.copy_button, 2)], self.butt_layout, self.butt_layout2, ) elif self.width() > 800 and self.butt_layout2.count() != 0: self._move_widgets( [(self.file_names_label, 1), (self.file_names, 1), (self.copy_button, 2)], self.butt_layout2, self.butt_layout, )
class MetabolitesMask(QWidget): """The input mask for a metabolites""" 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() def add_anno_row(self): i = self.annotation.rowCount() self.annotation.insertRow(i) self.changed = True def apply(self): try: self.metabolite.id = self.id.text() except ValueError: turn_red(self.id) QMessageBox.information( self, 'Invalid id', 'Could not apply changes identifier ' + self.id.text()+' already used.') else: self.metabolite.name = self.name.text() self.metabolite.formula = self.formula.text() if self.charge.text() == "": self.metabolite.charge = None else: self.metabolite.charge = int(self.charge.text()) self.metabolite.compartment = self.compartment.text() self.metabolite.annotation = {} rows = self.annotation.rowCount() for i in range(0, rows): key = self.annotation.item(i, 0).text() if self.annotation.item(i, 1) is None: value = "" else: value = self.annotation.item(i, 1).text() self.metabolite.annotation[key] = value self.changed = False self.metaboliteChanged.emit(self.metabolite) def validate_id(self): with self.appdata.project.cobra_py_model as model: text = self.id.text() if text == "": turn_red(self.id) return False if ' ' in text: turn_red(self.id) return False try: m = cobra.Metabolite(id=self.id.text()) model.add_metabolites([m]) except ValueError: turn_red(self.id) return False else: turn_white(self.id) return True def validate_name(self): with self.appdata.project.cobra_py_model as model: try: m = cobra.Metabolite(id="test_id", name=self.name.text()) model.add_metabolites([m]) except ValueError: turn_red(self.name) return False else: turn_white(self.name) return True def validate_formula(self): return True def validate_charge(self): try: if self.charge.text() != "": _x = int(self.charge.text()) except ValueError: turn_red(self.charge) return False else: turn_white(self.charge) return True def validate_compartment(self): try: if ' ' in self.compartment.text(): turn_red(self.compartment) return False if '-' in self.compartment.text(): turn_red(self.compartment) return False _m = cobra.Metabolite(id="test_id", name=self.compartment.text()) except ValueError: turn_red(self.compartment) return False else: turn_white(self.compartment) return True def validate_mask(self): valid_id = self.validate_id() valid_name = self.validate_name() valid_formula = self.validate_formula() valid_charge = self.validate_charge() valid_compartment = self.validate_compartment() if valid_id & valid_name & valid_formula & valid_charge & valid_compartment: self.is_valid = True else: self.is_valid = False def metabolites_data_changed(self): self.changed = True self.validate_mask() if self.is_valid: self.apply() self.update_state() def update_state(self): self.reactions.clear() if self.appdata.project.cobra_py_model.metabolites.has_id(self.id.text()): metabolite = self.appdata.project.cobra_py_model.metabolites.get_by_id( self.id.text()) for r in metabolite.reactions: item = QTreeWidgetItem(self.reactions) item.setText(0, r.id) item.setText(1, r.name) item.setData(2, 0, r) text = "Id: " + r.id + "\nName: " + r.name item.setToolTip(1, text) def emit_jump_to_reaction(self, reaction): self.jumpToReaction.emit(reaction.data(2, 0).id) jumpToReaction = Signal(str) metaboliteChanged = Signal(cobra.Metabolite)
class RgbSelectionWidget(QWidget): signal_update_map_selections = Signal() def __init__(self): super().__init__() self._range_table = [] self._limit_table = [] self._rgb_keys = ["red", "green", "blue"] self._rgb_dict = {_: None for _ in self._rgb_keys} widget_layout = self._setup_rgb_widget() self.setLayout(widget_layout) sp = QSizePolicy() sp.setControlType(QSizePolicy.PushButton) sp.setHorizontalPolicy(QSizePolicy.Expanding) sp.setVerticalPolicy(QSizePolicy.Fixed) self.setSizePolicy(sp) def _setup_rgb_element(self, n_row, *, rb_check=0): """ Parameters ---------- rb_check: int The number of QRadioButton to check. Typically this would be the row number. """ combo_elements = ComboBoxNamed(name=f"{n_row}") # combo_elements.setSizeAdjustPolicy(QComboBox.AdjustToContents) # Set text color for QComboBox widget (necessary if the program is used with Dark theme) pal = combo_elements.palette() pal.setColor(QPalette.ButtonText, Qt.black) combo_elements.setPalette(pal) # Set text color for drop-down view (necessary if the program is used with Dark theme) pal = combo_elements.view().palette() pal.setColor(QPalette.Text, Qt.black) combo_elements.view().setPalette(pal) btns = [QRadioButton(), QRadioButton(), QRadioButton()] if 0 <= rb_check < len(btns): btns[rb_check].setChecked(True) # Color is set for operation with Dark theme for btn in btns: pal = btn.palette() pal.setColor(QPalette.Text, Qt.black) btn.setPalette(pal) btn_group = QButtonGroup() for btn in btns: btn_group.addButton(btn) rng = RangeManager(name=f"{n_row}", add_sliders=True) rng.setTextColor([0, 0, 0]) # Set text color to 'black' # Set some text in edit boxes (just to demonstrate how the controls will look like) rng.le_min_value.setText("0.0") rng.le_max_value.setText("1.0") rng.setAlignment(Qt.AlignCenter) return combo_elements, btns, rng, btn_group def _enable_selection_events(self, enable): if enable: if not self.elements_btn_groups_events_enabled: for btn_group in self.elements_btn_groups: btn_group.buttonToggled.connect(self.rb_toggled) for el_combo in self.elements_combo: el_combo.currentIndexChanged.connect( self.combo_element_current_index_changed) for el_range in self.elements_range: el_range.selection_changed.connect( self.range_selection_changed) self.elements_btn_groups_events_enabled = True else: if self.elements_btn_groups_events_enabled: for btn_group in self.elements_btn_groups: btn_group.buttonToggled.disconnect(self.rb_toggled) for el_combo in self.elements_combo: el_combo.currentIndexChanged.disconnect( self.combo_element_current_index_changed) # Disconnecting the Range Manager signals is not necessary, but let's do it for consistency for el_range in self.elements_range: el_range.selection_changed.disconnect( self.range_selection_changed) self.elements_btn_groups_events_enabled = False def _setup_rgb_widget(self): self.elements_combo = [] self.elements_rb_color = [] self.elements_range = [] self.elements_btn_groups = [] self.elements_btn_groups_events_enabled = False self.row_colors = [] self.table = QTableWidget() # Horizontal header entries tbl_labels = ["Element", "Red", "Green", "Blue", "Range"] # The list of columns that stretch with the table self.tbl_cols_stretch = ("Range", ) self.table.setColumnCount(len(tbl_labels)) self.table.setRowCount(3) self.table.setHorizontalHeaderLabels(tbl_labels) self.table.verticalHeader().hide() self.table.setSelectionMode(QTableWidget.NoSelection) header = self.table.horizontalHeader() for n, lbl in enumerate(tbl_labels): # Set stretching for the columns if lbl in self.tbl_cols_stretch: header.setSectionResizeMode(n, QHeaderView.Stretch) else: header.setSectionResizeMode(n, QHeaderView.ResizeToContents) vheader = self.table.verticalHeader() vheader.setSectionResizeMode(QHeaderView.Stretch) # ResizeToContents) for n_row in range(3): combo_elements, btns, rng, btn_group = self._setup_rgb_element( n_row, rb_check=n_row) combo_elements.setMinimumWidth(180) self.table.setCellWidget(n_row, 0, combo_elements) for i, btn in enumerate(btns): item = QWidget() item_hbox = QHBoxLayout(item) item_hbox.addWidget(btn) item_hbox.setAlignment(Qt.AlignCenter) item_hbox.setContentsMargins(0, 0, 0, 0) item.setMinimumWidth(70) self.table.setCellWidget(n_row, i + 1, item) rng.setMinimumWidth(200) rng.setMaximumWidth(400) self.table.setCellWidget(n_row, 4, rng) self.elements_combo.append(combo_elements) self.elements_rb_color.append(btns) self.elements_range.append(rng) self.elements_btn_groups.append(btn_group) self.row_colors.append(self._rgb_keys[n_row]) # Colors that are used to paint rows of the table in RGB colors br = 150 self._rgb_row_colors = { "red": (255, br, br), "green": (br, 255, br), "blue": (br, br, 255) } self._rgb_color_keys = ["red", "green", "blue"] # Set initial colors for n_row in range(self.table.rowCount()): self._set_row_color(n_row) self._enable_selection_events(True) self.table.resizeRowsToContents() # Table height is computed based on content. It doesn't seem # to account for the height of custom widgets, but the table # looks good enough table_height = 0 for n_row in range(self.table.rowCount()): table_height += self.table.rowHeight(n_row) self.table.setMaximumHeight(table_height) table_width = 650 self.table.setMinimumWidth(table_width) self.table.setMaximumWidth(800) hbox = QHBoxLayout() hbox.addWidget(self.table) return hbox def combo_element_current_index_changed(self, name, index): if index < 0 or index >= len(self._range_table): return n_row = int(name) sel_eline = self._range_table[index][0] row_color = self.row_colors[n_row] self._rgb_dict[row_color] = sel_eline self.elements_range[n_row].set_range(self._range_table[index][1], self._range_table[index][2]) self.elements_range[n_row].set_selection( value_low=self._limit_table[index][1], value_high=self._limit_table[index][2]) self._update_map_selections() def range_selection_changed(self, v_low, v_high, name): n_row = int(name) row_color = self.row_colors[n_row] sel_eline = self._rgb_dict[row_color] ind = None try: ind = [_[0] for _ in self._limit_table].index(sel_eline) except ValueError: pass if ind is not None: self._limit_table[ind][1] = v_low self._limit_table[ind][2] = v_high self._update_map_selections() # We are not preventing users to select the same emission line in to rows. # Update the selected limits in other rows where the same element is selected. for nr, el_range in enumerate(self.elements_range): if (nr != n_row) and (self._rgb_dict[self.row_colors[nr]] == sel_eline): el_range.set_selection(value_low=v_low, value_high=v_high) def _get_selected_row_color(self, n_row): color_key = None btns = self.elements_rb_color[n_row] for n, btn in enumerate(btns): if btn.isChecked(): color_key = self._rgb_color_keys[n] break return color_key def _set_row_color(self, n_row, *, color_key=None): """ Parameters ---------- n_row: int The row number that needs background color change (0..2 if table has 3 rows) color_key: int Color key: "red", "green" or "blue" """ if color_key is None: color_key = self._get_selected_row_color(n_row) if color_key is None: return self.row_colors[n_row] = color_key rgb = self._rgb_row_colors[color_key] # The following code is based on the arrangement of the widgets in the table # Modify the code if widgets are arranged differently or the table structure # is changed for n_col in range(self.table.columnCount()): wd = self.table.cellWidget(n_row, n_col) if n_col == 0: # Combo box: update both QComboBox and QWidget backgrounds # QWidget - background of the drop-down selection list css1 = get_background_css(rgb, widget="QComboBox", editable=False) css2 = get_background_css(rgb, widget="QWidget", editable=True) wd.setStyleSheet(css2 + css1) elif n_col <= 3: # 3 QRadioButton's. The buttons are inserted into QWidget objects, # and we need to change backgrounds of QWidgets, not only buttons. wd.setStyleSheet( get_background_css(rgb, widget="QWidget", editable=False)) elif n_col == 4: # Custom RangeManager widget, color is updated using custom method wd.setBackground(rgb) n_col = self._rgb_color_keys.index(color_key) for n, n_btn in enumerate(self.elements_rb_color[n_row]): check_status = True if n == n_col else False n_btn.setChecked(check_status) def _fill_table(self): self._enable_selection_events(False) eline_list = [_[0] for _ in self._range_table] for n_row in range(self.table.rowCount()): self.elements_combo[n_row].clear() self.elements_combo[n_row].addItems(eline_list) for n_row, color in enumerate(self._rgb_color_keys): # Initially set colors in order self._set_row_color(n_row, color_key=color) eline_key = self._rgb_dict[color] if eline_key is not None: try: ind = eline_list.index(eline_key) self.elements_combo[n_row].setCurrentIndex(ind) range_low, range_high = self._range_table[ind][1:] self.elements_range[n_row].set_range(range_low, range_high) sel_low, sel_high = self._limit_table[ind][1:] self.elements_range[n_row].set_selection( value_low=sel_low, value_high=sel_high) except ValueError: pass else: self.elements_combo[n_row].setCurrentIndex(-1) # Deselect all self.elements_range[n_row].set_range(0, 1) self.elements_range[n_row].set_selection(value_low=0, value_high=1) self._enable_selection_events(True) def _find_rbutton(self, button): for nr, btns in enumerate(self.elements_rb_color): for nc, btn in enumerate(btns): if btn == button: # Return tuple (nr, nc) return nr, nc # Return None if the button is not found (this shouldn't happen) return None def rb_toggled(self, button, state): if state: # Ignore signals from unchecked buttons nr, nc = self._find_rbutton(button) color_current = self.row_colors[nr] color_to_set = self._rgb_color_keys[nc] nr_switch = self.row_colors.index(color_to_set) self._enable_selection_events(False) self._set_row_color(nr, color_key=color_to_set) self._set_row_color(nr_switch, color_key=color_current) # Swap selected maps tmp = self._rgb_dict[color_to_set] self._rgb_dict[color_to_set] = self._rgb_dict[color_current] self._rgb_dict[color_current] = tmp self._enable_selection_events(True) self._update_map_selections() def set_ranges_and_limits(self, *, range_table=None, limit_table=None, rgb_dict=None): if range_table is not None: self._range_table = copy.deepcopy(range_table) if limit_table is not None: self._limit_table = copy.deepcopy(limit_table) if rgb_dict is not None: self._rgb_dict = rgb_dict.copy() self._fill_table() def _update_map_selections(self): """Upload the selections (limit table) and update plot""" self.signal_update_map_selections.emit()
class PMGRuleCtrl(BaseExtendedWidget): """ rules: {'name':'regex', 'text':'匹配正则表达式', 'init':False } """ def __init__(self, layout_dir='v', title='', rules: List[Dict[str, Union[bool, int, float, str]]] = None): super().__init__(layout_dir) self.table_h_headers = [] self.table_keys = [] self.initial_values = [] for rule in rules: self.table_h_headers.append(rule['text']) self.table_keys.append(rule['name']) self.initial_values.append(rule['init']) self.regulations_table = QTableWidget(0, len(self.table_h_headers)) self.regulations_table.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) self.regulations_table.setHorizontalHeaderLabels(self.table_h_headers) self.layout().addWidget(self.regulations_table) self.set_layout = QHBoxLayout() self.layout().addLayout(self.set_layout) self.button_add = QPushButton('Add') self.button_remove = QPushButton('Remove') self.set_layout.addWidget(self.button_add) self.set_layout.addWidget(self.button_remove) self.button_add.clicked.connect(self.add_regulation) self.button_remove.clicked.connect(self.remove_regulation) def load_regulations(self, regulations: List[Dict[str, Union[int, str, float, bool]]]): row_count = len(regulations) self.regulations_table.setRowCount(row_count) for i, regulation in enumerate(regulations): l = [regulation[k] for k in self.table_keys] for j, obj in enumerate(l): item = QTableWidgetItem() item.setData(0, obj) self.regulations_table.setItem(i, j, item) def add_regulation(self): rc = self.regulations_table.rowCount() self.regulations_table.setRowCount(rc + 1) for i, obj in enumerate(self.initial_values): item = QTableWidgetItem() item.setData(0, obj) self.regulations_table.setItem(rc, i, item) def remove_regulation(self): self.regulations_table.removeRow(self.regulations_table.currentRow()) def get_value(self) -> List[Dict]: l = [] for i in range(self.regulations_table.rowCount()): dic = {} for j in range(self.regulations_table.columnCount()): item = self.regulations_table.item(i, j) dic[self.table_keys[j]] = item.data(0) l.append(dic) return l def set_value(self, value): self.load_regulations(value)
class AddDataTableMixin(object): """ Mixin providing validation and type casting for a table for adding cycle data. Should be used as part of a widget that has a `table` attribute. If it also has a `okButton`, this will be enabled/diabled when validation is performed. """ invalid = Signal(int, int) """ **signal** invalid(int `row`, int `col`) Emitted if the data in cell `row`,`col` is invalid. """ def __init__(self, *args, emptyDateValid=True, **kwargs): super().__init__(*args, **kwargs) self.headerLabels = ['Date', 'Time', 'Distance (km)', 'Calories', 'Gear'] self.headerLabelColumnOffset = 0 self.table = QTableWidget(0, len(self.headerLabels)) self.table.setHorizontalHeaderLabels(self.headerLabels) self.table.verticalHeader().setVisible(False) # dict of methods to validate and cast types for input data in each column isDatePartial = partial(isDate, allowEmpty=emptyDateValid) validateMethods = [isDatePartial, isDuration, isFloat, isFloat, isInt] parseDatePartial = partial(parseDate, pd_timestamp=True) castMethods = [parseDatePartial, parseDuration, float, float, int] self.mthds = {name:{'validate':validateMethods[i], 'cast':castMethods[i]} for i, name in enumerate(self.headerLabels)} self.validateTimer = QTimer() self.validateTimer.setInterval(100) self.validateTimer.setSingleShot(True) self.validateTimer.timeout.connect(self._validate) self.table.cellChanged.connect(self.validateTimer.start) self.invalid.connect(self._invalid) @property def defaultBrush(self): # made this a property rather than setting in constructor as the mixin # doesn't have a `table` attribute when __init__ is called return self.table.item(0,0).background() @property def invalidBrush(self): return QBrush(QColor("#910404")) @Slot(int, int) def _invalid(self, row, col): """ Set the background of cell `row`,`col` to the `invalidBrush` and disable the 'Ok' button. """ self.table.item(row, col).setBackground(self.invalidBrush) if hasattr(self, "okButton"): self.okButton.setEnabled(False) @Slot() def _validate(self): """ Validate all data in the table. If data is valid and the widget has an `okButton`, it will be enabled. """ # it would be more efficient to only validate a single cell, after its # text has been changed, but this table is unlikely to ever be more # than a few rows long, so this isn't too inefficient allValid = True for row in range(self.table.rowCount()): for col, name in enumerate(self.headerLabels): col += self.headerLabelColumnOffset item = self.table.item(row, col) value = item.text() mthd = self.mthds[name]['validate'] valid = mthd(value) if not valid: if hasattr(self, "_clicked"): if (row, col) not in self._clicked: continue self.invalid.emit(row, col) allValid = False elif valid and self.table.item(row, col).background() == self.invalidBrush: self.table.item(row, col).setBackground(self.defaultBrush) if allValid and hasattr(self, "okButton"): self.okButton.setEnabled(True) return allValid def _getValues(self): values = {name:[] for name in self.headerLabels} self.table.sortItems(0, Qt.AscendingOrder) for row in range(self.table.rowCount()): for col, name in enumerate(self.headerLabels): item = self.table.item(row, col) value = item.text() mthd = self.mthds[name]['cast'] value = mthd(value) values[name].append(value) return values
class D0(QGroupBox): def __init__(self, parent=None): self._parent = parent super().__init__(parent) self.setTitle("Define d₀") layout = QVBoxLayout() self.d0_grid_switch = QComboBox() self.d0_grid_switch.addItems(["Constant", "Field"]) self.d0_grid_switch.currentTextChanged.connect(self.set_case) layout.addWidget(self.d0_grid_switch) self.d0_box = QWidget() d0_box_layout = QHBoxLayout() d0_box_layout.addWidget(QLabel("d₀")) validator = QDoubleValidator() validator.setBottom(0) self.d0 = QLineEdit() self.d0.setValidator(validator) self.d0.editingFinished.connect(self.update_d0) d0_box_layout.addWidget(self.d0) d0_box_layout.addWidget(QLabel("Δd₀")) self.d0e = QLineEdit() self.d0e.setValidator(validator) self.d0e.editingFinished.connect(self.update_d0) d0_box_layout.addWidget(self.d0e) self.d0_box.setLayout(d0_box_layout) layout.addWidget(self.d0_box) load_save = QWidget() load_save_layout = QHBoxLayout() self.load_grid = QPushButton("Load d₀ Grid") self.load_grid.clicked.connect(self.load_d0_field) load_save_layout.addWidget(self.load_grid) self.save_grid = QPushButton("Save d₀ Grid") self.save_grid.clicked.connect(self.save_d0_field) load_save_layout.addWidget(self.save_grid) load_save.setLayout(load_save_layout) layout.addWidget(load_save) self.d0_grid = QTableWidget() self.d0_grid.setColumnCount(5) self.d0_grid.setColumnWidth(0, 60) self.d0_grid.setColumnWidth(1, 60) self.d0_grid.setColumnWidth(2, 60) self.d0_grid.setColumnWidth(3, 60) self.d0_grid.verticalHeader().setVisible(False) self.d0_grid.horizontalHeader().setStretchLastSection(True) self.d0_grid.setHorizontalHeaderLabels(['vx', 'vy', 'vz', "d₀", "Δd₀"]) spinBoxDelegate = SpinBoxDelegate() self.d0_grid.setItemDelegateForColumn(3, spinBoxDelegate) self.d0_grid.setItemDelegateForColumn(4, spinBoxDelegate) layout.addWidget(self.d0_grid) self.setLayout(layout) self.set_case('Constant') def set_case(self, case): if case == "Constant": self.d0_box.setEnabled(True) self.load_grid.setEnabled(False) self.save_grid.setEnabled(False) self.d0_grid.setEnabled(False) else: self.d0_box.setEnabled(False) self.load_grid.setEnabled(True) self.save_grid.setEnabled(True) self.d0_grid.setEnabled(True) def update_d0(self): self._parent.update_plot() def set_d0(self, d0, d0e): if d0 is None: self.d0.clear() self.d0e.clear() else: self.d0.setText(str(d0)) self.d0e.setText(str(d0e)) def set_d0_field(self, x, y, z, d0, d0e): if x is None: self.d0_grid.clearContents() else: self.d0_grid.setRowCount(len(x)) for n in range(len(x)): x_item = QTableWidgetItem(f'{x[n]: 7.2f}') x_item.setFlags(x_item.flags() ^ Qt.ItemIsEditable) y_item = QTableWidgetItem(f'{y[n]: 7.2f}') y_item.setFlags(y_item.flags() ^ Qt.ItemIsEditable) z_item = QTableWidgetItem(f'{z[n]: 7.2f}') z_item.setFlags(z_item.flags() ^ Qt.ItemIsEditable) d0_item = QTableWidgetItem() d0_item.setData(Qt.EditRole, float(d0[n])) d0e_item = QTableWidgetItem() d0e_item.setData(Qt.EditRole, float(d0e[n])) self.d0_grid.setItem(n, 0, QTableWidgetItem(x_item)) self.d0_grid.setItem(n, 1, QTableWidgetItem(y_item)) self.d0_grid.setItem(n, 2, QTableWidgetItem(z_item)) self.d0_grid.setItem(n, 3, QTableWidgetItem(d0_item)) self.d0_grid.setItem(n, 4, QTableWidgetItem(d0e_item)) def get_d0_field(self): if self.d0_grid.rowCount() == 0: return None else: x = [ float(self.d0_grid.item(row, 0).text()) for row in range(self.d0_grid.rowCount()) ] y = [ float(self.d0_grid.item(row, 1).text()) for row in range(self.d0_grid.rowCount()) ] z = [ float(self.d0_grid.item(row, 2).text()) for row in range(self.d0_grid.rowCount()) ] d0 = [ float(self.d0_grid.item(row, 3).text()) for row in range(self.d0_grid.rowCount()) ] d0e = [ float(self.d0_grid.item(row, 4).text()) for row in range(self.d0_grid.rowCount()) ] return (d0, d0e, x, y, z) def save_d0_field(self): filename, _ = QFileDialog.getSaveFileName( self, "Save d0 Grid", "", "CSV (*.csv);;All Files (*)") if filename: d0, d0e, x, y, z = self.get_d0_field() np.savetxt(filename, np.array([x, y, z, d0, d0e]).T, fmt=['%.4g', '%.4g', '%.4g', '%.9g', '%.9g'], header="vx, vy, vz, d0, d0_error", delimiter=',') def load_d0_field(self): filename, _ = QFileDialog.getOpenFileName( self, "Load d0 Grid", "", "CSV (*.csv);;All Files (*)") if filename: x, y, z, d0, d0e = np.loadtxt(filename, delimiter=',', unpack=True) self.set_d0_field(x, y, z, d0, d0e) def get_d0(self): if self.d0_grid_switch.currentText() == "Constant": try: return (float(self.d0.text()), float(self.d0e.text())) except ValueError: return None else: return self.get_d0_field()
class Extension2ReaderTable(QWidget): """Table showing extension to reader mappings with removal button. Widget presented in preferences-plugin dialog.""" valueChanged = Signal(int) def __init__(self, parent=None, npe2_readers=None, npe1_readers=None): super().__init__(parent=parent) npe2, npe1 = get_all_readers() if npe2_readers is None: npe2_readers = npe2 if npe1_readers is None: npe1_readers = npe1 self._npe2_readers = npe2_readers self._npe1_readers = npe1_readers self._table = QTableWidget() self._table.setShowGrid(False) self._set_up_table() self._edit_row = self._make_new_preference_row() self._populate_table() instructions = QLabel( trans. _('Enter a filename pattern to associate with a reader e.g. "*.tif" for all TIFF files.' ) + trans. _('Available readers will be filtered to those compatible with your pattern. Hover over a reader to see what patterns it accepts.' ) + trans. _('\n\nPreference saving for folder readers is not supported, so these readers are not shown.' ) + trans. _('\n\nFor documentation on valid filename patterns, see https://docs.python.org/3/library/fnmatch.html' )) instructions.setWordWrap(True) instructions.setOpenExternalLinks(True) layout = QVBoxLayout() instructions.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Expanding) layout.addWidget(instructions) layout.addWidget(self._edit_row) layout.addWidget(self._table) self.setLayout(layout) def _set_up_table(self): """Add table columns and headers, define styling""" self._fn_pattern_col = 0 self._reader_col = 1 header_strs = [trans._('Filename Pattern'), trans._('Reader Plugin')] self._table.setColumnCount(2) self._table.setColumnWidth(self._fn_pattern_col, 200) self._table.setColumnWidth(self._reader_col, 200) self._table.verticalHeader().setVisible(False) self._table.setMinimumHeight(120) self._table.horizontalHeader().setStyleSheet( 'border-bottom: 2px solid white;') self._table.setHorizontalHeaderLabels(header_strs) self._table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) def _populate_table(self): """Add row for each extension to reader mapping in settings""" fnpattern2reader = get_settings().plugins.extension2reader if len(fnpattern2reader) > 0: for fn_pattern, plugin_name in fnpattern2reader.items(): self._add_new_row(fn_pattern, plugin_name) else: # Display that there are no filename patterns with reader associations self._display_no_preferences_found() def _make_new_preference_row(self): """Make row for user to add a new filename pattern assignment""" edit_row_widget = QWidget() edit_row_widget.setLayout(QGridLayout()) edit_row_widget.layout().setContentsMargins(0, 0, 0, 0) self._fn_pattern_edit = QLineEdit() self._fn_pattern_edit.setPlaceholderText( "Start typing filename pattern...") self._fn_pattern_edit.textChanged.connect( self._filter_compatible_readers) add_reader_widg = QWidget() add_reader_widg.setLayout(QHBoxLayout()) add_reader_widg.layout().setContentsMargins(0, 0, 0, 0) self._new_reader_dropdown = QComboBox() for i, (plugin_name, display_name) in enumerate( sorted(dict(self._npe2_readers, **self._npe1_readers).items())): self._add_reader_choice(i, plugin_name, display_name) add_btn = QPushButton('Add') add_btn.setToolTip(trans._('Save reader preference for pattern')) add_btn.clicked.connect(self._save_new_preference) add_reader_widg.layout().addWidget(self._new_reader_dropdown) add_reader_widg.layout().addWidget(add_btn) edit_row_widget.layout().addWidget( self._fn_pattern_edit, 0, 0, ) edit_row_widget.layout().addWidget(add_reader_widg, 0, 1) return edit_row_widget def _display_no_preferences_found(self): self._table.setRowCount(1) item = QTableWidgetItem(trans._('No filename preferences found.')) item.setFlags(Qt.NoItemFlags) self._table.setItem(self._fn_pattern_col, 0, item) def _add_reader_choice(self, i, plugin_name, display_name): """Add dropdown item for plugin_name with reader pattern tooltip""" reader_patterns = get_filename_patterns_for_reader(plugin_name) # TODO: no reader_patterns means directory reader, # we don't support preference association yet if not reader_patterns: return self._new_reader_dropdown.addItem(display_name, plugin_name) if '*' in reader_patterns: tooltip_text = 'Accepts all' else: reader_patterns_formatted = ', '.join(sorted( list(reader_patterns))) tooltip_text = f'Accepts: {reader_patterns_formatted}' self._new_reader_dropdown.setItemData(i, tooltip_text, role=Qt.ToolTipRole) def _filter_compatible_readers(self, new_pattern): """Filter reader dropwdown items to those that accept `new_extension`""" self._new_reader_dropdown.clear() readers = self._npe2_readers.copy() to_delete = [] compatible_readers = get_potential_readers(new_pattern) for plugin_name, display_name in readers.items(): if plugin_name not in compatible_readers: to_delete.append(plugin_name) for reader in to_delete: del readers[reader] readers.update(self._npe1_readers) if not readers: self._new_reader_dropdown.addItem("None available") else: for i, (plugin_name, display_name) in enumerate(sorted(readers.items())): self._add_reader_choice(i, plugin_name, display_name) def _save_new_preference(self, event): """Save current preference to settings and show in table""" fn_pattern = self._fn_pattern_edit.text() reader = self._new_reader_dropdown.currentData() if not fn_pattern or not reader: return # if user types pattern that starts with a . it's probably a file extension so prepend the * if fn_pattern.startswith('.'): fn_pattern = f'*{fn_pattern}' if fn_pattern in get_settings().plugins.extension2reader: self._edit_existing_preference(fn_pattern, reader) else: self._add_new_row(fn_pattern, reader) get_settings().plugins.extension2reader = { **get_settings().plugins.extension2reader, fn_pattern: reader, } def _edit_existing_preference(self, fn_pattern, reader): """Edit existing extension preference""" current_reader_label = self.findChild(QLabel, fn_pattern) if reader in self._npe2_readers: reader = self._npe2_readers[reader] current_reader_label.setText(reader) def _add_new_row(self, fn_pattern, reader): """Add new reader preference to table""" last_row = self._table.rowCount() if (last_row == 1 and 'No filename preferences found' in self._table.item(0, 0).text()): self._table.removeRow(0) last_row = 0 self._table.insertRow(last_row) item = QTableWidgetItem(fn_pattern) item.setFlags(Qt.NoItemFlags) self._table.setItem(last_row, self._fn_pattern_col, item) plugin_widg = QWidget() # need object name to easily find row plugin_widg.setObjectName(f'{fn_pattern}') plugin_widg.setLayout(QHBoxLayout()) plugin_widg.layout().setContentsMargins(0, 0, 0, 0) if reader in self._npe2_readers: reader = self._npe2_readers[reader] plugin_label = QLabel(reader, objectName=fn_pattern) # need object name to easily work out which button was clicked remove_btn = QPushButton('X', objectName=fn_pattern) remove_btn.setFixedWidth(30) remove_btn.setStyleSheet('margin: 4px;') remove_btn.setToolTip( trans._('Remove this filename pattern to reader association')) remove_btn.clicked.connect(self.remove_existing_preference) plugin_widg.layout().addWidget(plugin_label) plugin_widg.layout().addWidget(remove_btn) self._table.setCellWidget(last_row, self._reader_col, plugin_widg) def remove_existing_preference(self, event): """Delete extension to reader mapping setting and remove table row""" pattern_to_remove = self.sender().objectName() current_settings = get_settings().plugins.extension2reader # need explicit assignment to new object here for persistence get_settings().plugins.extension2reader = { k: v for k, v in current_settings.items() if k != pattern_to_remove } for i in range(self._table.rowCount()): row_widg_name = self._table.cellWidget( i, self._reader_col).objectName() if row_widg_name == pattern_to_remove: self._table.removeRow(i) break if self._table.rowCount() == 0: self._display_no_preferences_found() def value(self): """Return extension:reader mapping from settings. Returns ------- Dict[str, str] mapping of extension to reader plugin display name """ return get_settings().plugins.extension2reader
class DialogSelectQuantStandard(QDialog): def __init__(self, parent=None): super().__init__(parent) self._qe_param_built_in = [] self._qe_param_custom = [] self._qe_standard_selected = None self._qe_param = [] # The list of all standards self._custom_label = [] # The list of booleans: True - the standard is custom, False -built-in self.setWindowTitle("Load Quantitative Standard") self.setMinimumHeight(500) self.setMinimumWidth(600) self.resize(600, 500) self.selected_standard_index = -1 labels = ("C", "Serial #", "Name", "Description") col_stretch = ( QHeaderView.ResizeToContents, QHeaderView.ResizeToContents, QHeaderView.ResizeToContents, QHeaderView.Stretch, ) self.table = QTableWidget() set_tooltip( self.table, "To <b> load the sta" "ndard</b>, double-click on the table row or " "select the table row and then click <b>Ok</b> button.", ) self.table.setMinimumHeight(200) self.table.setColumnCount(len(labels)) self.table.verticalHeader().hide() self.table.setHorizontalHeaderLabels(labels) self.table.setSelectionBehavior(QTableWidget.SelectRows) self.table.setSelectionMode(QTableWidget.SingleSelection) self.table.itemSelectionChanged.connect(self.item_selection_changed) self.table.itemDoubleClicked.connect(self.item_double_clicked) self.table.setStyleSheet( "QTableWidget::item{color: black;}" "QTableWidget::item:selected{background-color: red;}" "QTableWidget::item:selected{color: white;}" ) header = self.table.horizontalHeader() for n, col_stretch in enumerate(col_stretch): # Set stretching for the columns header.setSectionResizeMode(n, col_stretch) self.lb_info = QLabel() self.lb_info.setText("Column 'C': * means that the standard is user-defined.") button_box = QDialogButtonBox(QDialogButtonBox.Open | QDialogButtonBox.Cancel) button_box.button(QDialogButtonBox.Cancel).setDefault(True) button_box.accepted.connect(self.accept) button_box.rejected.connect(self.reject) self.pb_open = button_box.button(QDialogButtonBox.Open) self.pb_open.setEnabled(False) vbox = QVBoxLayout() vbox.addWidget(self.table) vbox.addWidget(self.lb_info) vbox.addWidget(button_box) self.setLayout(vbox) def _fill_table(self, table_contents): self.table.setRowCount(len(table_contents)) for nr, row in enumerate(table_contents): for nc, entry in enumerate(row): s = textwrap.fill(entry, width=40) item = QTableWidgetItem(s) item.setFlags(item.flags() & ~Qt.ItemIsEditable) if not nc: item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter) self.table.setItem(nr, nc, item) self.table.resizeRowsToContents() brightness = 220 for nr in range(self.table.rowCount()): for nc in range(self.table.columnCount()): self.table.item(nr, nc) if nr % 2: color = QColor(255, brightness, brightness) else: color = QColor(brightness, 255, brightness) self.table.item(nr, nc).setBackground(QBrush(color)) try: index = self._qe_param.index(self._qe_standard_selected) self.selected_standard_index = index n_columns = self.table.columnCount() self.table.setRangeSelected(QTableWidgetSelectionRange(index, 0, index, n_columns - 1), True) except ValueError: pass def item_selection_changed(self): sel_ranges = self.table.selectedRanges() # The table is configured to have one or no selected ranges # 'Open' button should be enabled only if a range (row) is selected if sel_ranges: self.selected_standard_index = sel_ranges[0].topRow() self.pb_open.setEnabled(True) else: self.selected_standard_index = -1 self.pb_open.setEnabled(False) def item_double_clicked(self): self.accept() def set_standards(self, qe_param_built_in, qe_param_custom, qe_standard_selected): self._qe_standard_selected = qe_standard_selected self._qe_param = qe_param_custom + qe_param_built_in custom_label = [True] * len(qe_param_custom) + [False] * len(qe_param_built_in) table_contents = [] for n, param in enumerate(self._qe_param): custom = "*" if custom_label[n] else "" serial = param["serial"] name = param["name"] description = param["description"] table_contents.append([custom, serial, name, description]) self._fill_table(table_contents) def get_selected_standard(self): if self.selected_standard_index >= 0: return self._qe_param[self.selected_standard_index] else: return None