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 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()
