def populate(self): """ Populates the table of fixed attributes """ self.widgets = [] # If no widgets, just drop that in numAttrs = self.data.numFixedAttributes() if not numAttrs: self.table.hide() self.noAttrLabel.show() return self.table.show() self.noAttrLabel.hide() self.table.setColumnCount(1) self.table.setRowCount(numAttrs) self.attrs = getAttrs(self.data.numFixedAttributes, self.data.fixedAttributeInfo, True) for row, (_, attr) in enumerate(self.attrs): item = QTableWidgetItem(attr.name) tooltip = '<p><tt> Name: {}<br> Type: {}<br>Count: {}</tt></p>'.\ format(attr.name, partio.TypeName(attr.type), attr.count) item.setToolTip(tooltip) self.table.setVerticalHeaderItem(row, item) value = self.data.getFixed(attr) widget = getWidget(value, self.data, attr) self.table.setCellWidget(row, 0, widget) self.widgets.append(widget) self.table.horizontalHeader().setStretchLastSection(False) self.table.setTabKeyNavigation(True) self.table.horizontalHeader().setSectionsMovable(False) self.table.horizontalHeader().resizeSections(QHeaderView.ResizeToContents) self.table.verticalHeader().resizeSections(QHeaderView.ResizeToContents)
def populate(self): """ Populate the table with the data """ self.clear() numAttr = self.data.numAttributes() numParticles = self.data.numParticles() self.attrs = getAttrs(self.data.numAttributes, self.data.attributeInfo, True) self.setColumnCount(numAttr) self.setRowCount(numParticles) self.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive) for col, (_, attr) in enumerate(self.attrs): item = QTableWidgetItem(attr.name) tooltip = '<p><tt> Name: {}<br> Type: {}<br>Count: {}</tt></p>'.\ format(attr.name, partio.TypeName(attr.type), attr.count) item.setToolTip(tooltip) self.setHorizontalHeaderItem(col, item) self.horizontalHeader().setStretchLastSection(False) self.setVerticalHeaderLabels( [str(pnum) for pnum in range(numParticles)]) self.setTabKeyNavigation(True) self.horizontalHeader().setSectionsMovable(False) # Populate it with the particle data self.widgets = [] for pnum in range(numParticles): self.populateParticle(pnum) self.horizontalHeader().resizeSections(QHeaderView.ResizeToContents) self.verticalHeader().resizeSections(QHeaderView.ResizeToContents)
def populate(self): """ Populate the table with the data """ self.clear() numAttr = self.data.numAttributes() numParticles = self.data.numParticles() self.attrs = getAttrs(self.data.numAttributes, self.data.attributeInfo, True) self.setColumnCount(numAttr) self.setRowCount(numParticles) self.horizontalHeader().setSectionResizeMode(QHeaderView.Interactive) for col, (_, attr) in enumerate(self.attrs): item = QTableWidgetItem(attr.name) tooltip = '<p><tt> Name: {}<br> Type: {}<br>Count: {}</tt></p>'.\ format(attr.name, partio.TypeName(attr.type), attr.count) item.setToolTip(tooltip) self.setHorizontalHeaderItem(col, item) self.horizontalHeader().setStretchLastSection(False) self.setVerticalHeaderLabels([str(pnum) for pnum in range(numParticles)]) self.setTabKeyNavigation(True) self.horizontalHeader().setSectionsMovable(False) # Populate it with the particle data self.widgets = [] for pnum in range(numParticles): self.populateParticle(pnum) self.horizontalHeader().resizeSections(QHeaderView.ResizeToContents) self.verticalHeader().resizeSections(QHeaderView.ResizeToContents)
def add_files(self, filenames): """add filenames (list(str)) to the table""" for f in filenames: row = self.table.rowCount() self.table.insertRow(row) file_item = QTableWidgetItem() file_item.setData(Qt.DisplayRole, f) self.table.setItem(row, 0, file_item) widget_that_lets_me_horizontally_align_an_icon = QWidget() widget_layout = QHBoxLayout( widget_that_lets_me_horizontally_align_an_icon) section_remove = QLabel() dim = int(1.5 * section_remove.fontMetrics().boundingRect("Z").height()) section_remove.setPixmap( QIcon(section_remove.style().standardIcon( QStyle.SP_DialogDiscardButton)).pixmap(dim, dim)) widget_layout.addWidget(section_remove, 0, Qt.AlignHCenter) widget_layout.setContentsMargins(0, 0, 0, 0) self.table.setCellWidget( row, 1, widget_that_lets_me_horizontally_align_an_icon) self.add_last_row()
def _on_add_token_value(self, *args): self.description_rule_text.blockSignals(True) token_text = self.tokens_list.currentItem().text() token = self._naming_lib.get_token(token_text) if token: key_data = token.add_token_value() if key_data: self.clean_tokens_key_table() keys = list() values = list() for i in range(len(key_data['key'])): self.values_table.insertRow(self.values_table.rowCount()) keys.append(QTableWidgetItem()) values.append(QTableWidgetItem()) for index, value in enumerate(key_data['key']): keys[index].setText(value) self.values_table.setItem(index, 0, keys[index]) for index, value in enumerate(key_data['value']): values[index].setText(value) self.values_table.setItem(index, 1, values[index]) self.update_default_token_list() # new_index = self.default_cbx.currentIndex() + 2 # self.default_cbx.setCurrentIndex(new_index) self.description_rule_text.blockSignals(False)
def addVar(name, source, selected=False): row = addVar.ind % maxrows col = int(addVar.ind / maxrows) item = QTableWidgetItem(name) item.source = source table.setItem(row, col, item) item.setSelected(selected) addVar.ind += 1
def add_last_row(self): """add the "add files" button to the bottom of the table""" row = self.table.rowCount() self.table.insertRow(row) add_row = QTableWidgetItem() add_row.setData(Qt.DisplayRole, "add files") self.table.setItem(row, 0, add_row)
def fill_table(self): """adds test names to the table""" mgr = self.session.test_manager for name in mgr.tests.keys(): row = self.table.rowCount() self.table.insertRow(row) test_name = QTableWidgetItem() test_name.setData(Qt.DisplayRole, name) self.table.setItem(row, 0, test_name)
def updateDataTable(self): """ Updates the table of data based on self.data dictionary """ n = len(self.data) table = self.dataTable table.setSortingEnabled(False) # Stops the table rearranging itself self.dataTable.cellChanged.disconnect(self.dataTableChanged) # Don't call the dataTableChanged function table.setRowCount(n) for row, name in enumerate(self.data): item = self.data[name] it = QTableWidgetItem(name) it.oldname = name # Save this for when it's changed table.setItem(row, 0, it) # Assume it's an XPadDataItem try: it = QTableWidgetItem(item.source) it.setFlags(it.flags() ^ Qt.ItemIsEditable) # Make source read only table.setItem(row, 1, it) except: table.setItem(row, 1, QTableWidgetItem("")) try: it = QTableWidgetItem(item.name) it.setFlags(it.flags() ^ Qt.ItemIsEditable) # Make trace read only table.setItem(row, 2, it) except: table.setItem(row, 2, QTableWidgetItem("")) try: try: comment = item.comment except AttributeError: comment = item.desc if comment == "": comment = item.label if item.units != "": comment += " ("+item.units+") " if item.dim != []: comment += " [" + item.dim[0].name for d in item.dim[1:]: comment += ", " + d.name comment += "] " else: comment += " = " + str(item.data) table.setItem(row, 3, QTableWidgetItem(comment)) except: table.setItem(row, 3, QTableWidgetItem(str(item))) table.setSortingEnabled(True) # Re-enable sorting self.dataTable.cellChanged.connect(self.dataTableChanged)
def setTag(self, tag): if(tag.isspace()==False and tag !=""): newItem = QTableWidgetItem(tag) newItem.setTextAlignment(QtCore.Qt.AlignCenter) self.tableWidget.setItem(self.row, self.column, newItem) if (self.column == 9 and self.row == 5): return elif (self.column == 9): self.row += 1 self.column = 0 else: self.column += 1
def add_ligand(tool): rows = tool.ligand_table.rowCount() if rows != 0: rows -= 1 ligand_name = QTableWidgetItem() name = "<click to choose>" is_c2 = Qt.Unchecked enabled = True if rows > 0: name = tool.ligand_table.item(rows - 1, 0).text() is_c2 = tool.ligand_table.cellWidget(rows - 1, 1).layout().itemAt(0).widget().checkState() enabled = tool.ligand_table.cellWidget(rows - 1, 1).layout().itemAt(0).widget().isEnabled() ligand_name.setData(Qt.DisplayRole, name) tool.ligand_table.setItem(rows, 0, ligand_name) widget_that_lets_me_horizontally_align_a_checkbox = QWidget() widget_layout = QHBoxLayout(widget_that_lets_me_horizontally_align_a_checkbox) c2 = QCheckBox() c2.setEnabled(enabled) c2.setCheckState(is_c2) widget_layout.addWidget(c2, 0, Qt.AlignHCenter) widget_layout.setContentsMargins(0, 0, 0, 0) tool.ligand_table.setCellWidget( rows, 1, widget_that_lets_me_horizontally_align_a_checkbox ) widget_that_lets_me_horizontally_align_an_icon = QWidget() widget_layout = QHBoxLayout(widget_that_lets_me_horizontally_align_an_icon) section_remove = QLabel() dim = int(1.5 * section_remove.fontMetrics().boundingRect("Q").height()) section_remove.setPixmap( QIcon(section_remove.style().standardIcon( QStyle.SP_DialogDiscardButton) ).pixmap(dim, dim) ) widget_layout.addWidget(section_remove, 0, Qt.AlignHCenter) widget_layout.setContentsMargins(0, 0, 0, 0) tool.ligand_table.setCellWidget( rows, 2, widget_that_lets_me_horizontally_align_an_icon ) rows += 1 tool.ligand_table.insertRow(rows) widget_that_lets_me_horizontally_align_an_icon = QWidget() widget_layout = QHBoxLayout(widget_that_lets_me_horizontally_align_an_icon) ligand_add = QLabel("add ligand") widget_layout.addWidget(ligand_add, 0, Qt.AlignHCenter) widget_layout.setContentsMargins(0, 0, 0, 0) tool.ligand_table.setCellWidget(rows, 1, widget_that_lets_me_horizontally_align_an_icon)
def _add_row(self, name, value): row = self.table.rowCount() self.table.setRowCount(row + 1) name = QTableWidgetItem(name) value = QTableWidgetItem(str(value)) delete = QPushButton("X") delete.name_item = name delete.clicked.connect(self._delete) self.table.blockSignals(True) self.table.setItem(row, 0, name) self.table.setItem(row, 1, value) self.table.setCellWidget(row, 2, delete) self.table.blockSignals(False)
def populate_clash_table_from_geometry(self, model): ''' If no simulation is running, use ChimeraX's built-in clash toolset to find and list geometric clashes in decreasing order of overlap severity. ''' atoms = model.atoms from chimerax.clashes import clashes clash_dict = clashes.find_clashes(self.session, atoms, inter_model=False) t = self._geom_clash_table t.setRowCount(0) if not clash_dict: return from functools import reduce # Clash dict is bi-directional, so number of clashes is half the total count clash_count = 1 / 2 * reduce(lambda x, y: x + y, (len(d.keys()) for d in clash_dict.values())) t.setRowCount(clash_count) seen = set() from chimerax.atomic import Atoms # Make list of unique clashing atom pairs and their distances clash_list = [] for a1, clashes in clash_dict.items(): seen.add(a1) for a2, dist in clashes.items(): if a2 in seen: continue clash_list.append((Atoms([a1, a2]), dist)) # Sort clashes in decreasing order of overlap clash_list = sorted(clash_list, key=lambda x: x[1], reverse=True) from Qt.QtWidgets import QTableWidgetItem for i, (catoms, overlap) in enumerate(clash_list): a1, a2 = catoms r1, r2 = catoms.residues data = ("{} {}{}: {}".format(r1.name, r1.chain_id, r1.number, a1.name), "{} {}{}: {}".format(r2.name, r2.chain_id, r2.number, a2.name), "{:0.2f}".format(overlap)) for j, d in enumerate(data): item = QTableWidgetItem(d) item.data = catoms t.setItem(i, j, item) t.resizeColumnsToContents()
def populate_clash_table_from_energies(self, atoms, clashing_indices, forces): ''' When running a simulation, list atoms that are experiencing extreme forces. This is preferable, since clashes in a static molecule can lead to extremely stretched bonds on energy minimization, with no van der Waals overlap to detect. Args: * atoms: - All currently-simulated atoms, in the order they were added to the simulation * clashing_indices: - Indices of atoms experiencing excessive forces, sorted in decreasing order of force magnitude * forces: - The forces on the clashing atoms, in decreasing order * clash_table: - The table to populate with details of the clashing atoms ''' catoms = atoms[clashing_indices] t = self._energy_clash_table t.setRowCount(0) if not len(catoms): return forces /= 10 # kJ mol-1 nm-1 to kJ mol-1 A-1 residues = catoms.residues chain_ids = residues.chain_ids resnames = residues.names resnums = residues.numbers anames = catoms.names from Qt.QtWidgets import QTableWidgetItem from chimerax.atomic import Atoms t.setRowCount(len(catoms)) for i, (a, cid, rname, rnum, aname, force) in enumerate( zip(catoms, chain_ids, resnames, resnums, anames, forces)): data = (cid, "{}-{}".format(rname, rnum), aname, "{:0.3g}".format(force)) aa = Atoms([a]) for j, d in enumerate(data): item = QTableWidgetItem(d) item.data = aa t.setItem(i, j, item) t.resizeColumnsToContents()
def update(self, *_): t = self.region_table t.setRowCount(0) m = self.isolde.selected_model if m is None: return from Qt.QtWidgets import QTableWidgetItem pa = self.problem_aggregator outliers_only = self.outliers_only_checkbox.isChecked() restraint_types = [ cb.text() for cb in self.restraint_checkboxes if cb.isChecked() ] validation_types = [ cb.text() for cb in self.validation_checkboxes if cb.isChecked() ] clusters, noise = pa.problem_zones( m, restraint_types=restraint_types, validation_types=validation_types, validation_outliers_only=outliers_only, cutoff=self.cutoff_spinbox.value(), min_points=self.cluster_spinbox.value()) t.clear() t.setColumnCount(1 + len(restraint_types) + len(validation_types)) t.setRowCount(len(clusters)) labels = [ t.replace(' ', '\n') for t in ['Total'] + restraint_types + validation_types ] t.setHorizontalHeaderLabels(labels) for i, cluster in enumerate(clusters): atoms = pa.cluster_atoms(cluster) issue_count = QTableWidgetItem(str(len(cluster))) issue_count.setData(self._data_role, atoms) t.setItem(i, 0, issue_count) for j, it in enumerate(restraint_types + validation_types): vtype = pa.registered_type(it) vcount = len([v for v in cluster if isinstance(v, vtype)]) t.setItem(i, j + 1, QTableWidgetItem(str(vcount)))
def addTag(self, tag): tags = [] for row in range(0, 4): for column in range(0, 9): try: tags.append(self.tableWidget.item(row, column).text()) except: continue if(tag.isspace()==False and tag not in tags and tag !=""): newItem = QTableWidgetItem(tag) newItem.setTextAlignment(QtCore.Qt.AlignCenter) self.tableWidget.setItem(self.row, self.column, newItem) if (self.column == 9 and self.row == 5): return elif (self.column == 9): self.row += 1 self.column = 0 else: self.column += 1
def attributeAddedSlot(self, name): # pylint:disable=W0613 """ SLOT when attribute is added """ numAttrs = self.data.numAttributes() anum = numAttrs - 1 name = str(name) # partio doesn't like unicode attr = self.data.attributeInfo(name) self.attrs.append((anum, attr)) self.setColumnCount(numAttrs) self.setHorizontalHeaderItem(numAttrs - 1, QTableWidgetItem(attr.name)) for pnum in range(self.data.numParticles()): self.populateAttribute(pnum, anum, attr, True) self.verticalHeader().resizeSections(QHeaderView.ResizeToContents)
def __init__(self): super(Window, self).__init__() layout = QHBoxLayout() self.setLayout(layout) self.table_widget = TableWidgetDragRows() layout.addWidget(self.table_widget) # setup table widget self.table_widget.setColumnCount(2) self.table_widget.setHorizontalHeaderLabels(['Type', 'Name']) items = [('Red', 'Toyota'), ('Blue', 'RV'), ('Green', 'Beetle'), ('Silver', 'Chevy'), ('Black', 'BMW')] self.table_widget.setRowCount(len(items)) for i, (color, model) in enumerate(items): self.table_widget.setItem(i, 0, QTableWidgetItem(color)) self.table_widget.setItem(i, 1, QTableWidgetItem(model)) self.resize(400, 400) self.show()
def update_tokens_key_table(self): item_text = self.tokens_list.currentItem().text() self.clean_tokens_key_table() if self.tokens_list.count() > 0: keys = [] values = [] tokens = self._naming_lib.tokens for token in tokens: if token.name != item_text: continue for i in range(len(token.values['key'])): self.values_table.insertRow(self.values_table.rowCount()) keys.append(QTableWidgetItem()) values.append(QTableWidgetItem()) for index, value in enumerate(token.values['key']): keys[index].setText(value) self.values_table.setItem(index, 0, keys[index]) for index, value in enumerate(token.values['value']): values[index].setText(value) self.values_table.setItem(index, 1, values[index])
def populate(self): """ Populates the table of fixed attributes """ self.widgets = [] # If no widgets, just drop that in numAttrs = self.data.numFixedAttributes() if not numAttrs: self.table.hide() self.noAttrLabel.show() return self.table.show() self.noAttrLabel.hide() self.table.setColumnCount(1) self.table.setRowCount(numAttrs) self.attrs = getAttrs(self.data.numFixedAttributes, self.data.fixedAttributeInfo, True) for row, (_, attr) in enumerate(self.attrs): item = QTableWidgetItem(attr.name) tooltip = '<p><tt> Name: {}<br> Type: {}<br>Count: {}</tt></p>'.\ format(attr.name, partio.TypeName(attr.type), attr.count) item.setToolTip(tooltip) self.table.setVerticalHeaderItem(row, item) value = self.data.getFixed(attr) widget = getWidget(value, self.data, attr) self.table.setCellWidget(row, 0, widget) self.widgets.append(widget) self.table.horizontalHeader().setStretchLastSection(False) self.table.setTabKeyNavigation(True) self.table.horizontalHeader().setSectionsMovable(False) self.table.horizontalHeader().resizeSections( QHeaderView.ResizeToContents) self.table.verticalHeader().resizeSections( QHeaderView.ResizeToContents)
def set_data(self): hor_headers = [] for n, key in enumerate(sorted(self.data.keys())): hor_headers.append(key) for m, item in enumerate(self.data[key]): new_item = QTableWidgetItem(item) self.setItem(m, n, new_item) self.setHorizontalHeaderLabels(hor_headers) for i in range(self.horizontalHeader().count()): self.horizontalHeader().setSectionResizeMode( i, QHeaderView.Stretch) self.resizeColumnsToContents() self.resizeRowsToContents()
def add_subs(self): from AaronTools.substituent import Substituent names = [] for lib in [Substituent.AARON_LIBS, Substituent.BUILTIN]: if not os.path.exists(lib): continue for ring in os.listdir(lib): name, ext = os.path.splitext(ring) if not any(".%s" % x == ext for x in read_types): continue if name in names: continue names.append(name) geom = Geometry( os.path.join(lib, ring), refresh_connected=False, refresh_ranks=False, ) conf_info = re.search(r"CF:(\d+),(\d+)", geom.comment) row = self.table.rowCount() self.table.insertRow(row) self.table.setItem(row, 0, QTableWidgetItem(name)) #the next two items are integers - need to initialize then setData so they sort and display correctly conf_num = QTableWidgetItem() conf_num.setData(Qt.DisplayRole, conf_info.group(1)) self.table.setItem(row, 1, conf_num) conf_angle = QTableWidgetItem() conf_angle.setData(Qt.DisplayRole, conf_info.group(2)) self.table.setItem(row, 2, conf_angle) self.substituent_list = names
def populate(self): """ Populates the table of indexed strings """ self.widgets = [] # If no widgets, just drop that in attrs = [] for anum in range(self.data.numAttributes()): attr = self.data.attributeInfo(anum) if attr.type == partio.INDEXEDSTR: attrs.append(attr) if not attrs: self.table.hide() self.noStringsLabel.show() return self.table.show() self.noStringsLabel.hide() self.table.setColumnCount(1) self.table.setRowCount(len(attrs)) for row, attr in enumerate(attrs): item = QTableWidgetItem(attr.name) self.table.setVerticalHeaderItem(row, item) strings = self.data.indexedStrs(attr) table = QTableWidget() table.setColumnCount(1) table.setRowCount(len(strings)) table.horizontalHeader().hide() table.setVerticalHeaderLabels( [str(i) for i in range(len(strings))]) for i, string in enumerate(strings): widget = QLabel(string) table.setCellWidget(i, 0, widget) self.widgets.append(widget) self.table.setCellWidget(row, 0, table) self.table.horizontalHeader().setStretchLastSection(False) self.table.setTabKeyNavigation(True) self.table.horizontalHeader().setSectionsMovable(False) self.table.horizontalHeader().resizeSections( QHeaderView.ResizeToContents) self.table.verticalHeader().resizeSections( QHeaderView.ResizeToContents)
def addVar(name, source, selected=False): var = source.variables[name] item = QTableWidgetItem(name) item.source = source table.setItem(addVar.ind, 0, item) item.setSelected(selected) comment = var.desc if comment == "": comment = var.label if var.units != "": comment += " (" + var.units + ") " if var.dim: try: dim_string = "[" + ", ".join([str(v) for v in var.dim]) + "]" except TypeError: dim_string = f"[{str(var.dim)}]" if dim_string != "[]": comment += f" {dim_string}" item = QTableWidgetItem(comment) table.setItem(addVar.ind, 1, item) item.setSelected(selected) addVar.ind += 1
def populateTable(self) -> None: row = 0 format = QAudioFormat() for codec in self.m_deviceInfo.supportedCodecs(): format.setCodec(codec) for sample_rate in self.m_deviceInfo.supportedSampleRates(): format.setSampleRate(sample_rate) for channel_count in self.m_deviceInfo.supportedChannelCounts( ): format.setChannelCount(channel_count) for sample_type in self.m_deviceInfo.supportedSampleTypes( ): format.setSampleType(sample_type) for sample_size in self.m_deviceInfo.supportedSampleSizes( ): format.setSampleType(sample_type) for endian in self.m_deviceInfo.supportedByteOrders( ): format.setByteOrder(endian) self.allFormatsTable.setRowCount(row + 1) codecItem = QTableWidgetItem(format.codec()) self.allFormatsTable.setItem(row, 0, codecItem) sampleRateItem = QTableWidgetItem( f"{format.sampleRate()}") self.allFormatsTable.setItem( row, 1, sampleRateItem) channelsItem = QTableWidgetItem( f"{format.channelCount()}") self.allFormatsTable.setItem( row, 2, channelsItem) sampleTypeItem = QTableWidgetItem( toString(format.sampleType())) self.allFormatsTable.setItem( row, 3, sampleTypeItem) sampleSizeItem = QTableWidgetItem( f"{format.sampleSize()}") self.allFormatsTable.setItem( row, 4, sampleSizeItem) byteOrderItem = QTableWidgetItem( toString(format.byteOrder())) self.allFormatsTable.setItem( row, 5, byteOrderItem) row += 1
def add_rings(self): from AaronTools.ring import Ring names = [] for lib in [Ring.AARON_LIBS, Ring.BUILTIN]: if not os.path.exists(lib): continue for ring in os.listdir(lib): name, ext = os.path.splitext(ring) if not any(".%s" % x == ext for x in read_types): continue if name in names: continue names.append(name) row = self.table.rowCount() self.table.insertRow(row) self.table.setItem(row, 0, QTableWidgetItem(name)) self.ring_list = names
def addVar(name, source, selected=False): var = source.variables[name] item = QTableWidgetItem(name) item.source = source table.setItem(addVar.ind, 0, item) item.setSelected(selected) comment = var.desc if comment == "": comment = var.label if var.units != "": comment += " ("+var.units+") " if var.dim: try: comment += " [" + ", ".join([str(v) for v in var.dim]) + "]" except TypeError: if str(var.dim): comment += " [" + str(var.dim) + "]" item = QTableWidgetItem(comment) table.setItem(addVar.ind, 1, item) item.setSelected(selected) addVar.ind += 1
def dropEvent(self, event): if not event.isAccepted() and event.source() == self: drop_row = self.drop_on(event) rows = sorted(set(item.row() for item in self.selectedItems())) rows_to_move = [[ QTableWidgetItem(self.item(row_index, column_index)) for column_index in range(self.columnCount()) ] for row_index in rows] for row_index in reversed(rows): self.removeRow(row_index) if row_index < drop_row: drop_row -= 1 for row_index, data in enumerate(rows_to_move): row_index += drop_row self.insertRow(row_index) for column_index, column_data in enumerate(data): self.setItem(row_index, column_index, column_data) event.accept() for row_index in range(len(rows_to_move)): self.item(drop_row + row_index, 0).setSelected(True) self.item(drop_row + row_index, 1).setSelected(True) super(TableWidgetDragRows, self).dropEvent(event)
def calc_sterimol(self, *args): self.settings.radii = self.radii_option.currentText() self.settings.display_radii = self.display_radii.checkState( ) == Qt.Checked self.settings.display_vectors = self.display_vectors.checkState( ) == Qt.Checked self.settings.at_L = self.at_L.value() self.settings.sterimol2vec = self.sterimol2vec.isChecked() self.settings.L_option = self.L_option.currentText() targets, neighbors, datas = sterimol_cmd( self.session, selected_atoms(self.session), radii=self.radii_option.currentText(), showVectors=self.display_vectors.checkState() == Qt.Checked, showRadii=self.display_radii.checkState() == Qt.Checked, return_values=True, at_L=self.at_L.value() if self.sterimol2vec.isChecked() else None, bisect_L=self.L_option.currentText() == "bisect angle between coordinating atoms", ) if len(targets) == 0: return if self.settings.delimiter == "comma": delim = "," elif self.settings.delimiter == "space": delim = " " elif self.settings.delimiter == "tab": delim = "\t" elif self.settings.delimiter == "semicolon": delim = ";" # self.table.setRowCount(0) for t, b, data in zip(targets, neighbors, datas): row = self.table.rowCount() self.table.insertRow(row) targ = QTableWidgetItem() targ.setData(Qt.DisplayRole, t) self.table.setItem(row, 0, targ) neigh = QTableWidgetItem() neigh.setData(Qt.DisplayRole, delim.join(b)) self.table.setItem(row, 1, neigh) l = np.linalg.norm(data["L"][1] - data["L"][0]) b1 = np.linalg.norm(data["B1"][1] - data["B1"][0]) b2 = np.linalg.norm(data["B2"][1] - data["B2"][0]) b3 = np.linalg.norm(data["B3"][1] - data["B3"][0]) b4 = np.linalg.norm(data["B4"][1] - data["B4"][0]) b5 = np.linalg.norm(data["B5"][1] - data["B5"][0]) li = QTableWidgetItem() li.setData(Qt.DisplayRole, "%.2f" % l) self.table.setItem(row, 7, li) b1i = QTableWidgetItem() b1i.setData(Qt.DisplayRole, "%.2f" % b1) self.table.setItem(row, 2, b1i) b2i = QTableWidgetItem() b2i.setData(Qt.DisplayRole, "%.2f" % b2) self.table.setItem(row, 3, b2i) b3i = QTableWidgetItem() b3i.setData(Qt.DisplayRole, "%.2f" % b3) self.table.setItem(row, 4, b3i) b4i = QTableWidgetItem() b4i.setData(Qt.DisplayRole, "%.2f" % b4) self.table.setItem(row, 5, b4i) b5i = QTableWidgetItem() b5i.setData(Qt.DisplayRole, "%.2f" % b5) self.table.setItem(row, 6, b5i) for i in range(0, 7): if i == 1: continue self.table.resizeColumnToContents(i)
def add_ligands(self, maxDenticity=None): from AaronTools.component import Component names = [] for lib in [Component.AARON_LIBS, Component.BUILTIN]: if not os.path.exists(lib): continue for lig in os.listdir(lib): name, ext = os.path.splitext(lig) if not any(".%s" % x == ext for x in read_types): continue if name in names: continue names.append(name) geom = Geometry( os.path.join(lib, lig), refresh_connected=False, refresh_ranks=False, ) key_atoms = [geom.atoms[i] for i in geom.other["key_atoms"]] if maxDenticity and len(key_atoms) > maxDenticity: continue row = self.table.rowCount() self.table.insertRow(row) self.table.setItem(row, 0, QTableWidgetItem(name)) #this is an integer, so I need to initialize it then set the data denticity = QTableWidgetItem() denticity.setData(Qt.DisplayRole, len(key_atoms)) self.table.setItem(row, 1, denticity) self.table.setItem( row, 2, QTableWidgetItem(", ".join( sorted([atom.element for atom in key_atoms])))) if self._include_substituents: from AaronTools.substituent import Substituent for lib in [Substituent.AARON_LIBS, Substituent.BUILTIN]: if not os.path.exists(lib): continue for sub in os.listdir(lib): name, ext = os.path.splitext(sub) if not any(".%s" % x == ext for x in read_types): continue if name in names: continue names.append(name) geom = Geometry( os.path.join(lib, sub), refresh_connected=False, refresh_ranks=False, ) key_atoms = [geom.atoms[0]] if maxDenticity and len(key_atoms) > maxDenticity: continue row = self.table.rowCount() self.table.insertRow(row) self.table.setItem(row, 0, QTableWidgetItem(name)) #this is an integer, so I need to initialize it then set the data denticity = QTableWidgetItem() denticity.setData(Qt.DisplayRole, len(key_atoms)) self.table.setItem(row, 1, denticity) self.table.setItem( row, 2, QTableWidgetItem(", ".join( sorted([atom.element for atom in key_atoms])))) self.ligand_list = names
def calc_cone(self, *args): self.settings.cone_option = self.cone_option.currentText() self.settings.radii = self.radii_option.currentText() self.settings.display_radii = self.display_radii.checkState( ) == Qt.Checked self.settings.display_cone = self.display_cone.checkState( ) == Qt.Checked if self.cone_option.currentText() == "Tolman (Unsymmetrical)": method = "tolman" else: method = self.cone_option.currentText() radii = self.radii_option.currentText() return_cones = self.display_cone.checkState() == Qt.Checked display_radii = self.display_radii.checkState() == Qt.Checked # self.table.setRowCount(0) for center_atom in selected_atoms(self.session): rescol = ResidueCollection(center_atom.structure) at_center = rescol.find_exact(AtomSpec(center_atom.atomspec))[0] if center_atom.structure in self.ligands: comp = Component( rescol.find([ AtomSpec(atom.atomspec) for atom in self.ligands[center_atom.structure] ]), to_center=rescol.find_exact(AtomSpec( center_atom.atomspec)), key_atoms=rescol.find(BondedTo(at_center)), ) else: comp = Component( rescol.find(NotAny(at_center)), to_center=rescol.find_exact(AtomSpec( center_atom.atomspec)), key_atoms=rescol.find(BondedTo(at_center)), ) cone_angle = comp.cone_angle( center=rescol.find(AtomSpec(center_atom.atomspec)), method=method, radii=radii, return_cones=return_cones, ) if return_cones: cone_angle, cones = cone_angle s = ".transparency 0.5\n" for cone in cones: apex, base, radius = cone s += ".cone %6.3f %6.3f %6.3f %6.3f %6.3f %6.3f %.3f open\n" % ( *apex, *base, radius) stream = BytesIO(bytes(s, "utf-8")) bild_obj, status = read_bild(self.session, stream, "Cone angle %s" % center_atom) self.session.models.add(bild_obj, parent=center_atom.structure) if display_radii: s = ".note radii\n" s += ".transparency 75\n" color = None for atom in comp.atoms: chix_atom = atom.chix_atom if radii.lower() == "umn": r = VDW_RADII[chix_atom.element.name] elif radii.lower() == "bondi": r = BONDI_RADII[chix_atom.element.name] if color is None or chix_atom.color != color: color = chix_atom.color rgb = [x / 255. for x in chix_atom.color] rgb.pop(-1) s += ".color %f %f %f\n" % tuple(rgb) s += ".sphere %f %f %f %f\n" % (*chix_atom.coord, r) stream = BytesIO(bytes(s, "utf-8")) bild_obj, status = read_bild(self.session, stream, "Cone angle radii") self.session.models.add(bild_obj, parent=center_atom.structure) row = self.table.rowCount() self.table.insertRow(row) name = QTableWidgetItem() name.setData(Qt.DisplayRole, center_atom.structure.name) self.table.setItem(row, 0, name) center = QTableWidgetItem() center.setData(Qt.DisplayRole, center_atom.atomspec) self.table.setItem(row, 1, center) ca = QTableWidgetItem() ca.setData(Qt.DisplayRole, "%.2f" % cone_angle) self.table.setItem(row, 2, ca) self.table.resizeColumnToContents(0) self.table.resizeColumnToContents(1) self.table.resizeColumnToContents(2)
def setParam(self, type, name, path): self.type = type self.filename = name self.filepath = path # 根据图片类型设置图片 if (type == "jpg" or type == "jpeg" or type == "png"): self.setPic(path) elif (type == "obj" or type == "fbx"): self.setObjPic() filepath = os.path.dirname(path) filename = filepath.split("/")[-1] self.let_filename.setText(filename) self.let_path.setText(filepath) tags = "" assetdb = client[type] assetcol = assetdb[name] for tagdic in assetcol.find({}, {"Tag": 1}): if "Tag" in tagdic: tag = tagdic["Tag"] tags += tag + "," self.let_tag.setText(tags) #设置资产操作记录表: assetdb = client[type] assetcol = assetdb[name] assetlist = assetcol.find({}, { "UserName": 1, "Operation": 1, "Time": 1 }) #rowcount = len(assetlist) #assetlist并不是列表类型 i = 0 # for x in assetlist: # i += 1 #求得行数减一 for xdir in assetlist: if "UserName" in xdir: str1 = xdir["UserName"] newItem1 = QTableWidgetItem(str1) self.tableWidget_operationNote.setItem(i, 0, newItem1) if "Time" in xdir: str3 = xdir["Time"] newItem3 = QTableWidgetItem(str3) self.tableWidget_operationNote.setItem(i, 2, newItem3) if "Operation" in xdir: str2 = xdir["Operation"] newItem2 = QTableWidgetItem(str2) self.tableWidget_operationNote.setItem(i, 1, newItem2) i += 1 self.saveBrowseNode(self.username, name, type) #保存浏览信息到库 # 链接信号与槽函数 self.btn_export.clicked.connect( lambda: self.exportModelToHoudini(name, type, path)) self.btn_exportToMaya.clicked.connect( lambda: self.exportModelToMaya(name, type, path))
def update_options_form(self): """Update the widget values in the options form, based on the current values in self.options """ filtered_options = copy.deepcopy(self.options) filtered_defaults = dict(BoutMesh.user_options_factory.defaults) filtered_defaults.update( tokamak.TokamakEquilibrium.user_options_factory.defaults) filtered_defaults.update( tokamak.TokamakEquilibrium.nonorthogonal_options_factory.defaults) # evaluate filtered_defaults using the values in self.options, so that any # expressions get evaluated filtered_default_values = dict( BoutMesh.user_options_factory.create(self.options)) try: filtered_default_values.update( tokamak.TokamakEquilibrium.user_options_factory.create( self.options)) if not hasattr(self, "eq"): filtered_default_values.update( tokamak.TokamakEquilibrium.nonorthogonal_options_factory. create(self.options)) else: # Use the object if it exists because some defaults are updated when the # Equilibrium is created filtered_default_values.update( self.eq.nonorthogonal_options_factory.create(self.options)) except (ValueError, TypeError) as e: self._popup_error_message(e) return # Skip options handled specially elsewhere filtered_options.pop("orthogonal", None) del filtered_defaults["orthogonal"] self.options_form.setSortingEnabled(False) self.options_form.cellChanged.disconnect(self.options_form_changed) self.options_form.setRowCount(len(filtered_defaults)) for row, (key, value) in enumerate(sorted(filtered_defaults.items())): item0 = QTableWidgetItem(key) item0.setFlags(item0.flags() & ~Qt.ItemIsEditable) item0.setToolTip(value.doc) self.options_form.setItem(row, 0, item0) if key in filtered_options: value_to_set = str(filtered_options[key]) else: value_to_set = f"{filtered_default_values[key]} (default)" item1 = QTableWidgetItem(value_to_set) item1.setToolTip(textwrap.fill(value.doc)) self.options_form.setItem(row, 1, item1) self.options_form.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) self.options_form.setSortingEnabled(True) self.options_form.cellChanged.connect(self.options_form_changed)
def fill_table(self, ndx): self.table.setRowCount(0) self.freq_table.setRowCount(0) self.fundamental_table.setRowCount(0) # self.overtone_table.setRowCount(0) self.combo_table.setRowCount(0) if ndx < 0: self.fundamental_table.setVisible(False) self.combo_table.setVisible(False) return fr = self.file_selector.currentData() item = QTableWidgetItem() item.setData(Qt.DisplayRole, "name") val = QTableWidgetItem() val.setData(Qt.DisplayRole, fr.name) self.table.insertRow(0) self.table.setItem(0, 0, item) self.table.setItem(0, 1, val) for info in fr.other.keys(): if info == "archive" and not self.settings.archive: continue if any( isinstance(fr.other[info], obj) for obj in [str, float, int]): row = self.table.rowCount() self.table.insertRow(row) item = QTableWidgetItem() info_name = info.replace("_", " ") val = fr.other[info] if info == "mass": info_name += " (%s)" % self.settings.mass if self.settings.mass == "Da": val /= UNIT.AMU_TO_KG elif info == "temperature": info_name += " (K)" elif (any(info == s for s in nrg_infos) or info.lower().endswith("energy") or info.startswith("E(")): if self.settings.energy == "Hartree": info_name += " (E<sub>h</sub>)" else: info_name += " (%s)" % self.settings.energy info_name = info_name.replace("orrelation", "orr.") info_name = info_name.replace("Same-spin", "SS") info_name = info_name.replace("Opposite-spin", "OS") if self.settings.energy == "kcal/mol": val *= UNIT.HART_TO_KCAL elif self.settings.energy == "kJ/mol": val *= 4.184 * UNIT.HART_TO_KCAL val = "%.6f" % val elif info.startswith("optical rotation"): info_name += " (°)" elif any(info == x for x in pg_infos): info_name = info.replace("_", " ") if re.search("\d", val): val = re.sub(r"(\d+)", r"<sub>\1</sub>", val) # gaussian uses * for infinity val = val.replace("*", "<sub>∞</sub>") # psi4 uses _inf_ val = val.replace("_inf_", "<sub>∞</sub>") if any(val.endswith(char) for char in "vhdsiVHDSI"): val = val[:-1] + "<sub>" + val[-1].lower() + "</sub>" if "<sub>" in info_name: self.table.setCellWidget(row, 0, QLabel(info_name)) else: item = QTableWidgetItem() item.setData(Qt.DisplayRole, info_name) self.table.setItem(row, 0, item) value = QTableWidgetItem() val = str(val) if "<sub>" in val: self.table.setCellWidget(row, 1, QLabel(val)) else: value.setData(Qt.DisplayRole, val) self.table.setItem(row, 1, value) elif isinstance(fr.other[info], Theory): theory = fr.other[info] if theory.method is not None: row = self.table.rowCount() self.table.insertRow(row) item = QTableWidgetItem() item.setData(Qt.DisplayRole, "method") self.table.setItem(row, 0, item) value = QTableWidgetItem() value.setData(Qt.DisplayRole, theory.method.name) self.table.setItem(row, 1, value) if theory.basis is not None: if theory.basis.basis: for basis in theory.basis.basis: row = self.table.rowCount() self.table.insertRow(row) item = QTableWidgetItem() if not basis.elements: item.setData(Qt.DisplayRole, "basis set") else: item.setData( Qt.DisplayRole, "basis for %s" % ", ".join(basis.elements)) self.table.setItem(row, 0, item) value = QTableWidgetItem() value.setData(Qt.DisplayRole, basis.name) self.table.setItem(row, 1, value) if theory.basis.ecp: for ecp in theory.basis.ecp: row = self.table.rowCount() self.table.insertRow(row) item = QTableWidgetItem() if ecp.elements is None: item.setData(Qt.DisplayRole, "ECP") else: item.setData(Qt.DisplayRole, "ECP %s" % " ".join(ecp.elements)) self.table.setItem(row, 0, item) value = QTableWidgetItem() value.setData(Qt.DisplayRole, ecp.name) self.table.setItem(row, 1, value) elif (hasattr(fr.other[info], "__iter__") and all(isinstance(x, float) for x in fr.other[info]) and len(fr.other[info]) > 1): row = self.table.rowCount() self.table.insertRow(row) item = QTableWidgetItem() info_name = info.replace("_", " ") vals = fr.other[info] if "rotational_temperature" in info: info_name = info_name.replace( "temperature", "constants (%s)" % self.settings.rot_const) if self.settings.rot_const == "GHz": vals = [ x * PHYSICAL.KB / (PHYSICAL.PLANCK * (10**9)) for x in vals ] item.setData(Qt.DisplayRole, info_name) self.table.setItem(row, 0, item) value = QTableWidgetItem() value.setData(Qt.DisplayRole, ", ".join(["%.4f" % x for x in vals])) self.table.setItem(row, 1, value) if "frequency" in fr.other: self.tabs.setTabEnabled(1, True) freq_data = fr.other['frequency'].data for i, mode in enumerate(freq_data): row = self.freq_table.rowCount() self.freq_table.insertRow(row) freq = FreqTableWidgetItem() freq.setData( Qt.DisplayRole, "%.2f%s" % (abs(mode.frequency), "i" if mode.frequency < 0 else "")) freq.setData(Qt.UserRole, i) self.freq_table.setItem(row, 0, freq) if mode.symmetry: text = mode.symmetry if re.search("\d", text): text = re.sub(r"(\d+)", r"<sub>\1</sub>", text) if text.startswith("SG"): text = "Σ" + text[2:] elif text.startswith("PI"): text = "Π" + text[2:] elif text.startswith("DLT"): text = "Δ" + text[3:] if any(text.endswith(char) for char in "vhdugVHDUG"): text = text[:-1] + "<sub>" + text[-1].lower( ) + "</sub>" label = QLabel(text) label.setAlignment(Qt.AlignCenter) self.freq_table.setCellWidget(row, 1, label) intensity = QTableWidgetItem() if mode.intensity is not None: intensity.setData(Qt.DisplayRole, round(mode.intensity, 2)) self.freq_table.setItem(row, 2, intensity) forcek = QTableWidgetItem() if mode.forcek is not None: forcek.setData(Qt.DisplayRole, round(mode.forcek, 2)) self.freq_table.setItem(row, 3, forcek) if fr.other["frequency"].anharm_data: self.fundamental_table.setVisible(True) self.combo_table.setVisible(True) freq = fr.other["frequency"] self.tabs.setTabEnabled(2, True) anharm_data = sorted( freq.anharm_data, key=lambda x: x.harmonic_frequency, ) for i, mode in enumerate(anharm_data): row = self.fundamental_table.rowCount() self.fundamental_table.insertRow(row) fund = FreqTableWidgetItem() fund.setData( Qt.DisplayRole, "%.2f%s" % (abs(mode.frequency), "i" if mode.frequency < 0 else "")) fund.setData(Qt.UserRole, i) self.fundamental_table.setItem(row, 0, fund) delta_anh = QTableWidgetItem() delta_anh.setData(Qt.DisplayRole, round(mode.delta_anh, 2)) self.fundamental_table.setItem(row, 1, delta_anh) intensity = QTableWidgetItem() if mode.intensity is not None: intensity.setData(Qt.DisplayRole, round(mode.intensity, 2)) self.fundamental_table.setItem(row, 2, intensity) for overtone in mode.overtones: row = self.combo_table.rowCount() self.combo_table.insertRow(row) fund = FreqTableWidgetItem() fund.setData( Qt.DisplayRole, "%.2f%s" % (abs(mode.frequency), "i" if mode.frequency < 0 else "")) fund.setData(Qt.UserRole, i) self.combo_table.setItem(row, 0, fund) fund = FreqTableWidgetItem() fund.setData(Qt.UserRole, i) self.combo_table.setItem(row, 1, fund) ot = FreqTableWidgetItem() ot.setData( Qt.DisplayRole, "%.2f%s" % (abs(overtone.frequency), "i" if overtone.frequency < 0 else "")) ot.setData(Qt.UserRole, i) self.combo_table.setItem(row, 2, ot) intensity = QTableWidgetItem() if overtone.intensity is not None: intensity.setData(Qt.DisplayRole, round(overtone.intensity, 2)) self.combo_table.setItem(row, 3, intensity) for key in mode.combinations: for combination in mode.combinations[key]: row = self.combo_table.rowCount() self.combo_table.insertRow(row) fund = FreqTableWidgetItem() fund.setData( Qt.DisplayRole, "%.2f%s" % (abs(mode.frequency), "i" if mode.frequency < 0 else "")) fund.setData(Qt.UserRole, i) self.combo_table.setItem(row, 0, fund) other_freq = freq.anharm_data[key].frequency fund = FreqTableWidgetItem() fund.setData( Qt.DisplayRole, "%.2f%s" % (abs(other_freq), "i" if other_freq < 0 else "")) fund.setData(Qt.UserRole, i + len(freq.anharm_data) * key) self.combo_table.setItem(row, 1, fund) combo = FreqTableWidgetItem() combo.setData( Qt.DisplayRole, "%.2f%s" % (abs(combination.frequency), "i" if combination.frequency < 0 else "")) combo.setData(Qt.UserRole, i) self.combo_table.setItem(row, 2, combo) intensity = QTableWidgetItem() if combination.intensity is not None: intensity.setData( Qt.DisplayRole, round(combination.intensity, 2)) self.combo_table.setItem(row, 3, intensity) else: self.fundamental_table.setVisible(False) self.combo_table.setVisible(False) self.tabs.setTabEnabled(2, False) else: self.fundamental_table.setVisible(False) self.combo_table.setVisible(False) self.tabs.setTabEnabled(1, False) self.tabs.setTabEnabled(2, False) self.table.resizeColumnToContents(0) self.table.resizeColumnToContents(1) self.freq_table.resizeColumnToContents(0) self.freq_table.resizeColumnToContents(1) self.freq_table.resizeColumnToContents(2) self.apply_filter()