class BoolEditor(BaseEditor, object):
attr_type = 'bool'
def __init__(self, parent=None, **kwargs):
super(BoolEditor, self).__init__(parent=parent, **kwargs)
self._default_value = False
self.cbx = QCheckBox(self)
self.main_layout.addWidget(self.cbx)
self.cbx.toggled.connect(self.OnValueUpdated)
def get_value(self):
return self.cbx.isChecked()
def initialize_editor(self):
editor_value = self.default_value
node_values = self.values
if node_values:
if len(node_values) > 1:
pass
elif len(node_values) == 1:
if node_values[0]:
editor_value = node_values[0]
self.cbx.blockSignals(True)
self.cbx.setChecked(editor_value)
self.cbx.blockSignals(False)
def set_connected(self, conn):
if conn != self._connection:
self._connection = conn
self.value_line.setText(conn)
self.cbx.setEnabled(False)
self.value_line.setProperty('class', 'Connected')
class Second(QMainWindow):
def __init__(self):
super(Second, self).__init__()
self.setWindowTitle("Add new device")
self.nameLabel = QLabel(self)
self.nameLabel.move(10, 10)
self.nameLabel.setText("Device name")
self.nameEntry = QLineEdit(self)
self.nameEntry.move(10, 40)
self.nameEntry.resize(100, 30)
self.colorLabel = QLabel(self)
self.colorLabel.move(120, 10)
self.colorLabel.setText("Color cameras")
self.colorEntry = QLineEdit(self)
self.colorEntry.move(140, 40)
self.colorEntry.resize(70, 30)
self.colorEntry.setValidator(QtGui.QIntValidator())
self.monoLabel = QLabel(self)
self.monoLabel.move(230, 10)
self.monoLabel.setText("Mono cameras")
self.monoEntry = QLineEdit(self)
self.monoEntry.move(250, 40)
self.monoEntry.resize(70, 30)
self.monoEntry.setValidator(QtGui.QIntValidator())
self.depthPresent = QCheckBox("Include depth", self)
self.depthPresent.move(10, 80)
self.depthPresent.resize(150, 30)
self.depthPresent.stateChanged.connect(self.toggle_depth)
self.leftfovLabel = QLabel(self)
self.leftfovLabel.move(10, 120)
self.leftfovLabel.setText("Left FOV deg.")
self.leftfovEntry = QLineEdit(self)
self.leftfovEntry.move(180, 120)
self.leftfovEntry.resize(140, 30)
self.leftfovEntry.setValidator(QtGui.QDoubleValidator())
self.rightfovLabel = QLabel(self)
self.rightfovLabel.move(10, 160)
self.rightfovLabel.setText("Right FOV deg.")
self.rightfovEntry = QLineEdit(self)
self.rightfovEntry.move(180, 160)
self.rightfovEntry.resize(140, 30)
self.rightfovEntry.setValidator(QtGui.QDoubleValidator())
self.rgbfovLabel = QLabel(self)
self.rgbfovLabel.move(10, 200)
self.rgbfovLabel.setText("RGB FOV deg.")
self.rgbfovEntry = QLineEdit(self)
self.rgbfovEntry.move(180, 200)
self.rgbfovEntry.resize(140, 30)
self.rgbfovEntry.setValidator(QtGui.QDoubleValidator())
self.lrdistanceLabel = QLabel(self)
self.lrdistanceLabel.move(10, 240)
self.lrdistanceLabel.resize(200, 30)
self.lrdistanceLabel.setText("Left - Right distance cm.")
self.lrdistanceEntry = QLineEdit(self)
self.lrdistanceEntry.move(180, 240)
self.lrdistanceEntry.resize(140, 30)
self.lrdistanceEntry.setValidator(QtGui.QDoubleValidator())
self.lrgbdistanceLabel = QLabel(self)
self.lrgbdistanceLabel.move(10, 280)
self.lrgbdistanceLabel.resize(200, 30)
self.lrgbdistanceLabel.setText("Left - RGB distance cm.")
self.lrgbdistanceEntry = QLineEdit(self)
self.lrgbdistanceEntry.move(180, 280)
self.lrgbdistanceEntry.resize(140, 30)
self.lrgbdistanceEntry.setValidator(QtGui.QDoubleValidator())
self.saveButton = QPushButton("Save", self)
self.saveButton.resize(100, 30)
self.saveButton.clicked.connect(self.save)
self.cancelButton = QPushButton("Cancel", self)
self.cancelButton.resize(100, 30)
self.cancelButton.clicked.connect(self.cancel)
self.toggle_depth(False)
def toggle_depth(self, checked):
if checked:
self.leftfovLabel.setVisible(True)
self.leftfovEntry.setVisible(True)
self.rightfovLabel.setVisible(True)
self.rightfovEntry.setVisible(True)
self.rgbfovLabel.setVisible(True)
self.rgbfovEntry.setVisible(True)
self.lrdistanceLabel.setVisible(True)
self.lrdistanceEntry.setVisible(True)
self.lrgbdistanceLabel.setVisible(True)
self.lrgbdistanceEntry.setVisible(True)
self.saveButton.move(200, 330)
self.cancelButton.move(30, 330)
self.resize(330, 380)
else:
self.leftfovLabel.setVisible(False)
self.leftfovEntry.setVisible(False)
self.rightfovLabel.setVisible(False)
self.rightfovEntry.setVisible(False)
self.rgbfovLabel.setVisible(False)
self.rgbfovEntry.setVisible(False)
self.lrdistanceLabel.setVisible(False)
self.lrdistanceEntry.setVisible(False)
self.lrgbdistanceLabel.setVisible(False)
self.lrgbdistanceEntry.setVisible(False)
self.saveButton.move(200, 120)
self.cancelButton.move(30, 120)
self.resize(330, 170)
def save(self, *args, **kwargs):
try:
data = {
"name": self.nameEntry.text(),
"color_count": int(self.colorEntry.text()),
"mono_count": int(self.monoEntry.text()),
}
if self.depthPresent.isChecked():
data.update({
"depth":
True,
"left_fov_deg":
float(self.leftfovEntry.text()),
"right_fov_deg":
float(self.rightfovEntry.text()),
"rgb_fov_deg":
float(self.rgbfovEntry.text()),
"left_to_right_distance_cm":
float(self.lrdistanceEntry.text()),
"left_to_rgb_distance_cm":
float(self.lrgbdistanceEntry.text()),
})
append_to_json(
data,
Path(__file__).parent.parent / Path('custom_devices.json'))
self.close()
INITIALIZE()
self.instance.getRegisteredTools(['NodeBoxTool'])[0].refresh()
except Exception as e:
QMessageBox.warning(self, "Warning", str(e))
def cancel(self):
self.close()
class BaseFileFolderDialog(BaseDialog,
abstract_dialog.AbstractFileFolderDialog):
"""
Base dialog classes for folders and files
"""
def_title = 'Select File'
def_size = (200, 125)
def_use_app_browser = False
def __init__(self, name='BaseFileFolder', parent=None, **kwargs):
super(BaseFileFolderDialog, self).__init__(name=name, parent=parent)
self.directory = None
self.filters = None
self._use_app_browser = kwargs.pop('use_app_browser',
self.def_use_app_browser)
self.set_filters('All Files (*.*)')
# By default, we set the directory to the user folder
self.set_directory(os.path.expanduser('~'))
self.center()
def open_app_browser(self):
return
def ui(self):
super(BaseFileFolderDialog, self).ui()
from tpDcc.libs.qt.widgets import directory
self.places = dict()
self.grid = layouts.GridLayout()
sub_grid = layouts.GridLayout()
self.grid.addWidget(QLabel('Path:'), 0, 0, Qt.AlignRight)
self.path_edit = QLineEdit(self)
self.path_edit.setReadOnly(True)
self.filter_box = QComboBox(self)
self.file_edit = QLineEdit(self)
self.view = directory.FileListWidget(self)
self.view.setWrapping(True)
self.view.setFocusPolicy(Qt.StrongFocus)
self.open_button = QPushButton('Select', self)
self.cancel_button = QPushButton('Cancel', self)
size = QSize(32, 24)
self.up_button = QPushButton('Up')
self.up_button.setToolTip('Go up')
self.up_button.setMinimumSize(size)
self.up_button.setMaximumSize(size)
size = QSize(56, 24)
self.refresh_button = QPushButton('Reload')
self.refresh_button.setToolTip('Reload file list')
self.refresh_button.setMinimumSize(size)
self.refresh_button.setMaximumSize(size)
self.show_hidden = QCheckBox('Hidden')
self.show_hidden.setChecked(False)
self.show_hidden.setToolTip('Toggle show hidden files')
sub_grid.addWidget(self.up_button, 0, 1)
sub_grid.addWidget(self.path_edit, 0, 2)
sub_grid.addWidget(self.refresh_button, 0, 3)
sub_grid.addWidget(self.show_hidden, 0, 4)
self.grid.addLayout(sub_grid, 0, 1)
self.grid.addWidget(self.get_drives_widget(), 1, 0)
self.grid.addWidget(self.view, 1, 1)
self.grid.addWidget(QLabel('File name:'), 7, 0, Qt.AlignRight)
self.grid.addWidget(self.file_edit, 7, 1)
self.filter_label = QLabel('Filter:')
self.grid.addWidget(self.filter_label, 8, 0, Qt.AlignRight)
self.grid.addWidget(self.filter_box, 8, 1)
hbox = layouts.GridLayout()
hbox.addWidget(self.open_button, 0, 0, Qt.AlignRight)
hbox.addWidget(self.cancel_button, 0, 1, Qt.AlignRight)
self.grid.addLayout(hbox, 9, 1, Qt.AlignRight)
self.main_layout.addLayout(self.grid)
self.setGeometry(200, 100, 600, 400)
self.open_button.clicked.connect(self.accept)
self.cancel_button.clicked.connect(self.reject)
self.up_button.clicked.connect(self.go_up)
self.refresh_button.clicked.connect(self.update_view)
self.show_hidden.stateChanged.connect(self.update_view)
self.view.directory_activated.connect(
self.activate_directory_from_view)
self.view.file_activated.connect(self.activate_file_from_view)
self.view.file_selected.connect(self.select_file_item)
self.view.folder_selected.connect(self.select_folder_item)
self.view.up_requested.connect(self.go_up)
self.view.update_requested.connect(self.update_view)
def exec_(self, *args, **kwargs):
if self._use_app_browser:
return self.open_app_browser()
else:
self.update_view()
self.filter_box.currentIndexChanged.connect(self.update_view)
accepted = super(BaseFileFolderDialog, self).exec_()
self.filter_box.currentIndexChanged.disconnect(self.update_view)
return self.get_result() if accepted == 1 else None
def set_filters(self, filters, selected=0):
self.filter_box.clear()
filter_types = filters.split(';;')
for ft in filter_types:
extensions = string.extract(ft, '(', ')')
filter_name = string.rstrips(ft, '({})'.format(extensions))
extensions = extensions.split(' ')
self.filter_box.addItem(
'{} ({})'.format(filter_name, ','.join(extensions)),
extensions)
if 0 <= selected < self.filter_box.count():
self.filter_box.setCurrentIndex(selected)
self.filters = filters
def get_drives_widget(self):
"""
Returns a QGroupBox widget that contains all disk drivers of the PC in a vertical layout
:return: QGroupBox
"""
w = QGroupBox('')
w.setParent(self)
box = layouts.VerticalLayout()
box.setAlignment(Qt.AlignTop)
places = [(getpass.getuser(),
os.path.realpath(os.path.expanduser('~')))]
places += [
(q, q) for q in
[os.path.realpath(x.absolutePath()) for x in QDir().drives()]
]
for label, loc in places:
icon = QFileIconProvider().icon(QFileInfo(loc))
drive_btn = QRadioButton(label)
drive_btn.setIcon(icon)
drive_btn.setToolTip(loc)
drive_btn.setProperty('path', loc)
drive_btn.clicked.connect(self.go_to_drive)
self.places[loc] = drive_btn
box.addWidget(drive_btn)
w.setLayout(box)
return w
def go_to_drive(self):
"""
Updates widget to show the content of the selected disk drive
"""
sender = self.sender()
self.set_directory(sender.property('path'), False)
def get_result(self):
tf = self.file_edit.text()
sf = self.get_file_path(tf)
return sf, os.path.dirname(sf), tf.split(os.pathsep)
def get_filter_patterns(self):
"""
Get list of filter patterns that are being used by the widget
:return: list<str>
"""
idx = self.filter_box.currentIndex()
if idx >= 0:
return self.filter_box.itemData(idx)
else:
return []
def get_file_path(self, file_name):
"""
Returns file path of the given file name taking account the selected directory
:param file_name: str, name of the file without path
:return: str
"""
sname = file_name.split(os.pathsep)[0]
return os.path.realpath(
os.path.join(os.path.abspath(self.directory), sname))
# def accept(self):
# self._overlay.close()
# super(BaseFileFolderDialog, self).accept()
#
#
# def reject(self):
# self._overlay.close()
# super(BaseFileFolderDialog, self).reject()
def update_view(self):
"""
Updates file/folder view
:return:
"""
self.view.clear()
qdir = QDir(self.directory)
qdir.setNameFilters(self.get_filter_patterns())
filters = QDir.Dirs | QDir.AllDirs | QDir.Files | QDir.NoDot | QDir.NoDotDot
if self.show_hidden.isChecked():
filters = filters | QDir.Hidden
entries = qdir.entryInfoList(filters=filters,
sort=QDir.DirsFirst | QDir.Name)
file_path = self.get_file_path('..')
if os.path.exists(file_path) and file_path != self.directory:
icon = QFileIconProvider().icon(QFileInfo(self.directory))
QListWidgetItem(icon, '..', self.view, 0)
for info in entries:
icon = QFileIconProvider().icon(info)
suf = info.completeSuffix()
name, tp = (info.fileName(), 0) if info.isDir() else (
'%s%s' % (info.baseName(), '.%s' % suf if suf else ''), 1)
QListWidgetItem(icon, name, self.view, tp)
self.view.setFocus()
def set_directory(self, path, check_drive=True):
"""
Sets the directory that you want to explore
:param path: str, valid path
:param check_drive: bool,
:return:
"""
self.directory = os.path.realpath(path)
self.path_edit.setText(self.directory)
self.file_edit.setText('')
# If necessary, update selected disk driver
if check_drive:
for loc in self.places:
rb = self.places[loc]
rb.setAutoExclusive(False)
rb.setChecked(loc.lower() == self.directory.lower())
rb.setAutoExclusive(True)
self.update_view()
self.up_button.setEnabled(not self.cant_go_up())
def go_up(self):
"""
Updates the current directory to go to its parent directory
"""
self.set_directory(os.path.dirname(self.directory))
def cant_go_up(self):
"""
Checks whether we can naviage to current selected parent directory or not
:return: bool
"""
return os.path.dirname(self.directory) == self.directory
def activate_directory_from_view(self, name):
"""
Updates selected directory
:param name: str, name of the directory
"""
self.set_directory(os.path.join(self.directory, name))
def activate_file_from_view(self, name):
"""
Updates selected file text and returns its info by accepting it
:param name: str, name of the file
"""
self.select_file_item(name=name)
self.accept()
def select_file_item(self, name):
"""
Updates selected file text and returns its info by accepting it
:param name: str, name of the file
"""
self.file_edit.setText(name)
def select_folder_item(self, name):
"""
Updates selected folder text and returns its info by accepting it
:param name: str, name of the folder
"""
self.file_edit.setText(name)
def addAttributeSlot(self):
""" Adds a new attribute (column) to the table """
dialog = QDialog(self)
dialog.setModal(True)
dialog.setWindowTitle('Add Attribute')
layout = QVBoxLayout()
dialog.setLayout(layout)
form = QFormLayout()
nameBox = QLineEdit()
typeCombo = QComboBox()
for attrType in _attrTypes:
typeName = partio.TypeName(attrType)
typeCombo.addItem(typeName)
typeCombo.setCurrentIndex(partio.FLOAT)
countBox = QLineEdit()
countBox.setValidator(QIntValidator())
countBox.setText('1')
fixedCheckbox = QCheckBox()
valueBox = QLineEdit()
valueBox.setText('0')
form.addRow('Name:', nameBox)
form.addRow('Type:', typeCombo)
form.addRow('Count:', countBox)
form.addRow('Fixed:', fixedCheckbox)
form.addRow('Default Value:', valueBox)
layout.addLayout(form)
buttons = QHBoxLayout()
layout.addLayout(buttons)
add = QPushButton('Add')
add.clicked.connect(dialog.accept)
buttons.addWidget(add)
cancel = QPushButton('Cancel')
cancel.clicked.connect(dialog.reject)
buttons.addWidget(cancel)
if not dialog.exec_():
return
name = str(nameBox.text())
if not name:
print('Please supply a name for the new attribute') # TODO: prompt
return
attrType = typeCombo.currentIndex()
count = int(countBox.text())
fixed = fixedCheckbox.isChecked()
values = list(str(valueBox.text()).strip().split())
for i in range(count):
if i < len(values):
value = values[i]
else:
value = values[-1]
if attrType == partio.INT or attrType == partio.INDEXEDSTR:
values[i] = int(value)
elif attrType == partio.FLOAT or attrType == partio.VECTOR:
values[i] = float(value) # pylint:disable=R0204
else:
values[i] = 0.0 # pylint:disable=R0204
value = tuple(values)
self.data.addAttribute(name, attrType, count, fixed, value)
class EditStructure(ToolInstance):
help = "https://github.com/QChASM/SEQCROW/wiki/Structure-Modification-Tool"
SESSION_ENDURING = False
SESSION_SAVE = False
def __init__(self, session, name):
super().__init__(session, name)
self.settings = _EditStructureSettings(session, "Structure Modification")
self.tool_window = MainToolWindow(self)
self.close_previous_bool = self.settings.modify
self._build_ui()
def _build_ui(self):
layout = QGridLayout()
self.alchemy_tabs = QTabWidget()
#substitute
substitute_tab = QWidget()
substitute_layout = QGridLayout(substitute_tab)
sublabel = QLabel("substituent name:")
substitute_layout.addWidget(sublabel, 0, 0, Qt.AlignVCenter)
self.subname = QLineEdit()
# self.subname.setText("Et")
sub_completer = NameCompleter(Substituent.list(), self.subname)
self.subname.setCompleter(sub_completer)
self.subname.setToolTip("name of substituent in the AaronTools library or your personal library\nseparate names with commas and uncheck 'modify selected structure' to create several structures")
substitute_layout.addWidget(self.subname, 0, 1, Qt.AlignVCenter)
open_sub_lib = QPushButton("from library...")
open_sub_lib.clicked.connect(self.open_sub_selector)
substitute_layout.addWidget(open_sub_lib, 0, 2, Qt.AlignTop)
substitute_layout.addWidget(QLabel("modify selected structure:"), 1, 0, 1, 1, Qt.AlignVCenter)
self.close_previous_sub = QCheckBox()
self.close_previous_sub.setToolTip("checked: selected structure will be modified\nunchecked: new model will be created for the modified structure")
self.close_previous_sub.setChecked(self.settings.modify)
self.close_previous_sub.stateChanged.connect(self.close_previous_change)
substitute_layout.addWidget(self.close_previous_sub, 1, 1, 1, 2, Qt.AlignTop)
substitute_layout.addWidget(QLabel("relax substituent:"), 2, 0, 1, 1, Qt.AlignVCenter)
self.minimize = QCheckBox()
self.minimize.setToolTip("spin the added substituents to try to minimize the LJ potential energy")
self.minimize.setChecked(self.settings.minimize)
substitute_layout.addWidget(self.minimize, 2, 1, 1, 1, Qt.AlignTop)
substitute_layout.addWidget(QLabel("guess previous substituent:"), 3, 0, 1, 1, Qt.AlignVCenter)
self.guess_old = QCheckBox()
self.guess_old.setToolTip("checked: leave the longest connected fragment in the residue\nunchecked: previous substituent must be selected")
self.guess_old.setChecked(self.settings.guess)
self.guess_old.stateChanged.connect(lambda state, settings=self.settings: settings.__setattr__("guess", True if state == Qt.Checked else False))
substitute_layout.addWidget(self.guess_old, 3, 1, 1, 2, Qt.AlignTop)
substitute_layout.addWidget(QLabel("new residue:"), 5, 0, 1, 1, Qt.AlignVCenter)
self.new_residue = QCheckBox()
self.new_residue.setToolTip("put the new substituent in its own residue instead\nof adding it to the residue of the old substituent")
self.new_residue.setChecked(self.settings.new_residue)
self.new_residue.stateChanged.connect(lambda state, settings=self.settings: settings.__setattr__("new_residue", True if state == Qt.Checked else False))
substitute_layout.addWidget(self.new_residue, 5, 1, 1, 2, Qt.AlignTop)
substitute_layout.addWidget(QLabel("use distance names:"), 4, 0, 1, 1, Qt.AlignVCenter)
self.use_greek = QCheckBox()
self.use_greek.setChecked(self.settings.use_greek)
self.use_greek.setToolTip("indicate distance from point of attachment with atom name")
substitute_layout.addWidget(self.use_greek, 4, 1, 1, 1, Qt.AlignTop)
substitute_layout.addWidget(QLabel("change residue name:"), 6, 0, 1, 1, Qt.AlignVCenter)
self.new_sub_name = QLineEdit()
self.new_sub_name.setToolTip("change name of modified residues")
self.new_sub_name.setPlaceholderText("leave blank to keep current")
substitute_layout.addWidget(self.new_sub_name, 6, 1, 1, 2, Qt.AlignTop)
substitute_button = QPushButton("substitute current selection")
substitute_button.clicked.connect(self.do_substitute)
substitute_layout.addWidget(substitute_button, 7, 0, 1, 3, Qt.AlignTop)
self.substitute_button = substitute_button
substitute_layout.setRowStretch(0, 0)
substitute_layout.setRowStretch(1, 0)
substitute_layout.setRowStretch(2, 0)
substitute_layout.setRowStretch(3, 0)
substitute_layout.setRowStretch(4, 0)
substitute_layout.setRowStretch(5, 0)
substitute_layout.setRowStretch(6, 0)
substitute_layout.setRowStretch(7, 1)
#map ligand
maplig_tab = QWidget()
maplig_layout = QGridLayout(maplig_tab)
liglabel = QLabel("ligand name:")
maplig_layout.addWidget(liglabel, 0, 0, Qt.AlignVCenter)
self.ligname = QLineEdit()
lig_completer = NameCompleter(Component.list(), self.ligname)
self.ligname.setCompleter(lig_completer)
self.ligname.setToolTip("name of ligand in the AaronTools library or your personal library\nseparate names with commas and uncheck 'modify selected structure' to create several structures")
maplig_layout.addWidget(self.ligname, 0, 1, Qt.AlignVCenter)
open_lig_lib = QPushButton("from library...")
open_lig_lib.clicked.connect(self.open_lig_selector)
maplig_layout.addWidget(open_lig_lib, 0, 2, Qt.AlignTop)
maplig_layout.addWidget(QLabel("modify selected structure:"), 1, 0, 1, 1, Qt.AlignVCenter)
self.close_previous_lig = QCheckBox()
self.close_previous_lig.setToolTip("checked: selected structure will be modified\nunchecked: new model will be created for the modified structure")
self.close_previous_lig.setChecked(self.settings.modify)
self.close_previous_lig.stateChanged.connect(self.close_previous_change)
maplig_layout.addWidget(self.close_previous_lig, 1, 1, 1, 2, Qt.AlignTop)
maplig_button = QPushButton("swap ligand with selected coordinating atoms")
maplig_button.clicked.connect(self.do_maplig)
maplig_layout.addWidget(maplig_button, 2, 0, 1, 3, Qt.AlignTop)
self.maplig_button = maplig_button
start_structure_button = QPushButton("place in:")
self.lig_model_selector = ModelComboBox(self.session, addNew=True)
start_structure_button.clicked.connect(self.do_new_lig)
maplig_layout.addWidget(start_structure_button, 3, 0, 1, 1, Qt.AlignTop)
maplig_layout.addWidget(self.lig_model_selector, 3, 1, 1, 2, Qt.AlignTop)
maplig_layout.setRowStretch(0, 0)
maplig_layout.setRowStretch(1, 0)
maplig_layout.setRowStretch(2, 0)
maplig_layout.setRowStretch(3, 1)
#close ring
closering_tab = QWidget()
closering_layout = QGridLayout(closering_tab)
ringlabel = QLabel("ring name:")
closering_layout.addWidget(ringlabel, 0, 0, Qt.AlignVCenter)
self.ringname = QLineEdit()
ring_completer = NameCompleter(Ring.list(), self.ringname)
self.ringname.setCompleter(ring_completer)
self.ringname.setToolTip("name of ring in the AaronTools library or your personal library\nseparate names with commas and uncheck 'modify selected structure' to create several structures")
closering_layout.addWidget(self.ringname, 0, 1, Qt.AlignVCenter)
open_ring_lib = QPushButton("from library...")
open_ring_lib.clicked.connect(self.open_ring_selector)
closering_layout.addWidget(open_ring_lib, 0, 2, Qt.AlignTop)
closering_layout.addWidget(QLabel("modify selected structure:"), 1, 0, 1, 1, Qt.AlignVCenter)
self.close_previous_ring = QCheckBox()
self.close_previous_ring.setToolTip("checked: selected structure will be modified\nunchecked: new model will be created for the modified structure")
self.close_previous_ring.setChecked(self.settings.modify)
self.close_previous_ring.stateChanged.connect(self.close_previous_change)
closering_layout.addWidget(self.close_previous_ring, 1, 1, 1, 2, Qt.AlignTop)
closering_layout.addWidget(QLabel("try multiple:"), 2, 0, 1, 1, Qt.AlignVCenter)
self.minimize_ring = QCheckBox()
self.minimize_ring.setToolTip("try to use other versions of this ring in the library to find the one that fits best")
self.minimize_ring.setChecked(self.settings.minimize_ring)
closering_layout.addWidget(self.minimize_ring, 2, 1, 1, 2, Qt.AlignTop)
closering_layout.addWidget(QLabel("new residue name:"), 3, 0, 1, 1, Qt.AlignVCenter)
self.new_ring_name = QLineEdit()
self.new_ring_name.setToolTip("change name of modified residues")
self.new_ring_name.setPlaceholderText("leave blank to keep current")
closering_layout.addWidget(self.new_ring_name, 3, 1, 1, 2, Qt.AlignTop)
closering_button = QPushButton("put a ring on current selection")
closering_button.clicked.connect(self.do_fusering)
closering_layout.addWidget(closering_button, 4, 0, 1, 3, Qt.AlignTop)
self.closering_button = closering_button
start_structure_button = QPushButton("place in:")
self.ring_model_selector = ModelComboBox(self.session, addNew=True)
start_structure_button.clicked.connect(self.do_new_ring)
closering_layout.addWidget(start_structure_button, 5, 0, 1, 1, Qt.AlignTop)
closering_layout.addWidget(self.ring_model_selector, 5, 1, 1, 2, Qt.AlignTop)
closering_layout.setRowStretch(0, 0)
closering_layout.setRowStretch(1, 0)
closering_layout.setRowStretch(2, 0)
closering_layout.setRowStretch(3, 0)
closering_layout.setRowStretch(4, 0)
closering_layout.setRowStretch(5, 1)
#change element
changeelement_tab = QWidget()
changeelement_layout = QFormLayout(changeelement_tab)
self.element = ElementButton("C", single_state=True)
self.element.clicked.connect(self.open_ptable)
changeelement_layout.addRow("element:", self.element)
self.vsepr = QComboBox()
self.vsepr.addItems([
"do not change", # 0
"linear (1 bond)", # 1
"linear (2 bonds)", # 2
"trigonal planar (2 bonds)", # 3
"tetrahedral (2 bonds)", # 4
"trigonal planar", # 5
"tetrahedral (3 bonds)", # 6
"T-shaped", # 7
"trigonal pyramidal", # 8
"tetrahedral", # 9
"sawhorse", #10
"seesaw", #11
"square planar", #12
"trigonal bipyramidal", #13
"square pyramidal", #14
"pentagonal", #15
"octahedral", #16
"hexagonal", #17
"trigonal prismatic", #18
"pentagonal pyramidal", #19
"capped octahedral", #20
"capped trigonal prismatic", #21
"heptagonal", #22
"hexagonal pyramidal", #23
"pentagonal bipyramidal", #24
"biaugmented trigonal prismatic", #25
"cubic", #26
"elongated trigonal bipyramidal", #27
"hexagonal bipyramidal", #28
"heptagonal pyramidal", #29
"octagonal", #30
"square antiprismatic", #31
"trigonal dodecahedral", #32
"capped cube", #33
"capped square antiprismatic", #34
"enneagonal", #35
"heptagonal bipyramidal", #36
"hula-hoop", #37
"triangular cupola", #38
"tridiminished icosahedral", #39
"muffin", #40
"octagonal pyramidal", #41
"tricapped trigonal prismatic", #42
])
self.vsepr.setCurrentIndex(9)
self.vsepr.insertSeparator(33)
self.vsepr.insertSeparator(25)
self.vsepr.insertSeparator(20)
self.vsepr.insertSeparator(16)
self.vsepr.insertSeparator(13)
self.vsepr.insertSeparator(8)
self.vsepr.insertSeparator(5)
self.vsepr.insertSeparator(2)
self.vsepr.insertSeparator(1)
self.vsepr.insertSeparator(0)
changeelement_layout.addRow("geometry:", self.vsepr)
self.change_bonds = QCheckBox()
self.change_bonds.setChecked(self.settings.change_bonds)
changeelement_layout.addRow("adjust bond lengths:", self.change_bonds)
change_element_button = QPushButton("change selected elements")
change_element_button.clicked.connect(self.do_change_element)
changeelement_layout.addRow(change_element_button)
self.change_element_button = change_element_button
start_structure_button = QPushButton("place in:")
self.model_selector = ModelComboBox(self.session, addNew=True)
start_structure_button.clicked.connect(self.do_new_atom)
changeelement_layout.addRow(start_structure_button, self.model_selector)
delete_atoms_button = QPushButton("delete selected atoms")
delete_atoms_button.clicked.connect(self.delete_atoms)
changeelement_layout.addRow(delete_atoms_button)
self.alchemy_tabs.addTab(substitute_tab, "substitute")
self.alchemy_tabs.addTab(maplig_tab, "swap ligand")
self.alchemy_tabs.addTab(closering_tab, "fuse ring")
self.alchemy_tabs.addTab(changeelement_tab, "change element")
layout.addWidget(self.alchemy_tabs)
self.tool_window.ui_area.setLayout(layout)
self.tool_window.manage(None)
def close_previous_change(self, state):
if state == Qt.Checked:
self.settings.modify = True
for checkbox in [self.close_previous_lig, self.close_previous_sub, self.close_previous_ring]:
checkbox.setChecked(True)
self.close_previous_bool = True
else:
self.settings.modify = False
for checkbox in [self.close_previous_lig, self.close_previous_sub, self.close_previous_ring]:
checkbox.setChecked(False)
self.close_previous_bool = False
def do_substitute(self):
subnames = self.subname.text()
new_name = self.new_sub_name.text()
use_attached = not self.guess_old.isChecked()
minimize = self.minimize.isChecked()
new_residue = self.new_residue.isChecked()
use_greek = self.use_greek.isChecked()
self.settings.minimize = minimize
self.settings.use_greek = use_greek
if len(new_name.strip()) > 0:
run(
self.session,
"substitute sel substituents %s newName %s guessAttachment %s modify %s minimize %s useRemoteness %s newResidue %s" %
(
subnames,
new_name,
not use_attached,
self.close_previous_bool,
minimize,
use_greek,
new_residue,
)
)
else:
run(
self.session,
"substitute sel substituents %s guessAttachment %s modify %s minimize %s useRemoteness %s newResidue %s" %
(
subnames,
not use_attached,
self.close_previous_bool,
minimize,
use_greek,
new_residue,
)
)
def open_sub_selector(self):
self.tool_window.create_child_window("select substituents", window_class=SubstituentSelection, textBox=self.subname)
def do_maplig(self):
lignames = self.ligname.text()
selection = selected_atoms(self.session)
if len(selection) < 1:
raise RuntimeWarning("nothing selected")
models = {}
for atom in selection:
if atom.structure not in models:
models[atom.structure] = [AtomSpec(atom.atomspec)]
else:
models[atom.structure].append(AtomSpec(atom.atomspec))
first_pass = True
new_structures = []
for ligname in lignames.split(','):
ligname = ligname.strip()
lig = Component(ligname)
for model in models:
if self.close_previous_bool and first_pass:
rescol = ResidueCollection(model)
elif self.close_previous_bool and not first_pass:
raise RuntimeError("only the first model can be replaced")
else:
model_copy = model.copy()
rescol = ResidueCollection(model_copy)
for i, atom in enumerate(model.atoms):
rescol.atoms[i].atomspec = atom.atomspec
rescol.atoms[i].add_tag(atom.atomspec)
rescol.atoms[i].chix_atom = atom
target = rescol.find(models[model])
if len(target) % len(lig.key_atoms) == 0:
k = 0
ligands = []
while k != len(target):
res_lig = ResidueCollection(lig.copy(), comment=lig.comment)
res_lig.parse_comment()
res_lig = Component(res_lig, key_atoms = ",".join([str(k + 1) for k in res_lig.other["key_atoms"]]))
ligands.append(res_lig)
k += len(lig.key_atoms)
else:
raise RuntimeError("number of key atoms no not match: %i now, new ligand has %i" % (len(target), len(lig.key_atoms)))
rescol.map_ligand(ligands, target)
for center_atom in rescol.center:
center_atom.connected = set([])
for atom in rescol.atoms:
if atom not in rescol.center:
if center_atom.is_connected(atom):
atom.connected.add(center_atom)
center_atom.connected.add(atom)
if self.close_previous_bool:
rescol.update_chix(model)
else:
struc = rescol.get_chimera(self.session)
new_structures.append(struc)
first_pass = False
if not self.close_previous_bool:
self.session.models.add(new_structures)
def open_lig_selector(self):
self.tool_window.create_child_window("select ligands", window_class=LigandSelection, textBox=self.ligname)
def do_fusering(self):
ring_names = self.ringname.text()
new_name = self.new_ring_name.text()
minimize_ring = self.minimize_ring.isChecked()
self.settings.minimize_ring = minimize_ring
if len(new_name.strip()) > 0:
run(
self.session,
"fuseRing sel rings %s newName %s modify %s minimize %s" % (
ring_names,
new_name,
self.close_previous_bool,
minimize_ring,
)
)
else:
run(
self.session,
"fuseRing sel rings %s modify %s minimize %s" % (
ring_names,
self.close_previous_bool,
minimize_ring,
)
)
def open_ring_selector(self):
self.tool_window.create_child_window("select rings", window_class=RingSelection, textBox=self.ringname)
def open_ptable(self):
self.tool_window.create_child_window("select element", window_class=_PTable, button=self.element)
def display_help(self):
"""Show the help for this tool in the help viewer."""
from chimerax.core.commands import run
run(self.session,
'open %s' % self.help if self.help is not None else "")
def do_change_element(self):
element = self.element.text()
adjust_bonds = self.change_bonds.isChecked()
self.settings.change_bonds = adjust_bonds
vsepr = self.vsepr.currentText()
if vsepr == "do not change":
vsepr = False
elif vsepr == "linear (1 bond)":
vsepr = "linear 1"
goal = 1
elif vsepr == "linear (2 bonds)":
vsepr = "linear 2"
goal = 2
elif vsepr == "trigonal planar (2 bonds)":
vsepr = "bent 2 planar"
goal = 2
elif vsepr == "tetrahedral (2 bonds)":
vsepr = "bent 2 tetrahedral"
goal = 2
elif vsepr == "trigonal planar":
goal = 3
elif vsepr == "tetrahedral (3 bonds)":
vsepr = "bent 3 tetrahedral"
goal = 3
else:
goal = len(Atom.get_shape(vsepr)) - 1
sel = selected_atoms(self.session)
models, _ = guessAttachmentTargets(sel, self.session, allow_adjacent=False)
for model in models:
conv_res = list(models[model].keys())
for res in models[model]:
for target in models[model][res]:
for neighbor in target.neighbors:
if neighbor.residue not in conv_res:
conv_res.append(neighbor.residue)
for pbg in self.session.models.list(type=PseudobondGroup):
for pbond in pbg.pseudobonds:
if target in pbond.atoms and all(atom.structure is model for atom in pbond.atoms):
other_atom = pbond.other_atom(target)
if other_atom.residue not in conv_res:
conv_res.append(other_atom.residue)
rescol = ResidueCollection(model, convert_residues=conv_res)
for res in models[model]:
residue = [resi for resi in rescol.residues if resi.chix_residue is res][0]
for target in models[model][res]:
targ = rescol.find_exact(AtomSpec(target.atomspec))[0]
adjust_hydrogens = vsepr
if vsepr is not False:
cur_bonds = len(targ.connected)
change_Hs = goal - cur_bonds
adjust_hydrogens = (change_Hs, vsepr)
residue.change_element(targ,
element,
adjust_bonds=adjust_bonds,
adjust_hydrogens=adjust_hydrogens,
)
residue.update_chix(res)
def do_new_ring(self):
rings = self.ringname.text()
for ring in rings.split(","):
ring = ring.strip()
rescol = ResidueCollection(Ring(ring))
model = self.ring_model_selector.currentData()
if model is None:
chix = rescol.get_chimera(self.session)
self.session.models.add([chix])
apply_seqcrow_preset(chix, fallback="Ball-Stick-Endcap")
self.ring_model_selector.setCurrentIndex(self.ring_model_selector.count()-1)
else:
res = model.new_residue("new", "a", len(model.residues)+1)
rescol.residues[0].update_chix(res)
run(self.session, "select add %s" % " ".join([atom.atomspec for atom in res.atoms]))
def do_new_lig(self):
ligands = self.ligname.text()
for lig in ligands.split(","):
lig = lig.strip()
rescol = ResidueCollection(Component(lig))
model = self.lig_model_selector.currentData()
if model is None:
chix = rescol.get_chimera(self.session)
self.session.models.add([chix])
apply_seqcrow_preset(chix, fallback="Ball-Stick-Endcap")
self.lig_model_selector.setCurrentIndex(self.lig_model_selector.count()-1)
else:
res = model.new_residue("new", "a", len(model.residues)+1)
rescol.residues[0].update_chix(res)
run(self.session, "select add %s" % " ".join([atom.atomspec for atom in res.atoms]))
def do_new_atom(self):
element = self.element.text()
adjust_bonds = self.change_bonds.isChecked()
self.settings.change_bonds = adjust_bonds
vsepr = self.vsepr.currentText()
if vsepr == "do not change":
vsepr = False
elif vsepr == "linear (1 bond)":
vsepr = "linear 1"
elif vsepr == "linear (2 bonds)":
vsepr = "linear 2"
elif vsepr == "trigonal planar (2 bonds)":
vsepr = "bent 2 planar"
elif vsepr == "tetrahedral (2 bonds)":
vsepr = "bent 2 tetrahedral"
elif vsepr == "tetrahedral (3 bonds)":
vsepr = "bent 3 tetrahedral"
if vsepr:
atoms = Atom.get_shape(vsepr)
atoms[0].element = element
for atom in atoms[1:]:
atom.element = "H"
if adjust_bonds:
# this works b/c all atoms are 1 angstrom from the center
# just multiply by the distance we want
expected_dist = RADII[element] + RADII["H"]
for atom in atoms[1:]:
atom.coords *= expected_dist
for atom in atoms[1:]:
atoms[0].connected.add(atom)
atom.connected.add(atoms[0])
else:
atoms = [Atom(element=element, coords=np.zeros(3))]
rescol = ResidueCollection(atoms, name="new", refresh_connected=False)
model = self.model_selector.currentData()
if model is None:
chix = rescol.get_chimera(self.session)
self.session.models.add([chix])
apply_seqcrow_preset(chix, fallback="Ball-Stick-Endcap")
self.model_selector.setCurrentIndex(self.model_selector.count()-1)
else:
res = model.new_residue("new", "a", len(model.residues)+1)
rescol.residues[0].update_chix(res)
run(self.session, "select add %s" % " ".join([atom.atomspec for atom in res.atoms]))
def delete_atoms(self, *args):
atoms = selected_atoms(self.session)
for atom in atoms:
atom.delete()
def delete(self):
self.ring_model_selector.deleteLater()
self.lig_model_selector.deleteLater()
self.model_selector.deleteLater()
return super().delete()
def close(self):
self.ring_model_selector.deleteLater()
self.lig_model_selector.deleteLater()
self.model_selector.deleteLater()
return super().close()
def addAttributeSlot(self):
""" Adds a new attribute (column) to the table """
dialog = QDialog(self)
dialog.setModal(True)
dialog.setWindowTitle('Add Attribute')
layout = QVBoxLayout()
dialog.setLayout(layout)
form = QFormLayout()
nameBox = QLineEdit()
typeCombo = QComboBox()
for attrType in _attrTypes:
typeName = partio.TypeName(attrType)
typeCombo.addItem(typeName)
typeCombo.setCurrentIndex(partio.FLOAT)
countBox = QLineEdit()
countBox.setValidator(QIntValidator())
countBox.setText('1')
fixedCheckbox = QCheckBox()
valueBox = QLineEdit()
valueBox.setText('0')
form.addRow('Name:', nameBox)
form.addRow('Type:', typeCombo)
form.addRow('Count:', countBox)
form.addRow('Fixed:', fixedCheckbox)
form.addRow('Default Value:', valueBox)
layout.addLayout(form)
buttons = QHBoxLayout()
layout.addLayout(buttons)
add = QPushButton('Add')
add.clicked.connect(dialog.accept)
buttons.addWidget(add)
cancel = QPushButton('Cancel')
cancel.clicked.connect(dialog.reject)
buttons.addWidget(cancel)
if not dialog.exec_():
return
name = str(nameBox.text())
if not name:
print 'Please supply a name for the new attribute' # TODO: prompt
return
attrType = typeCombo.currentIndex()
count = int(countBox.text())
fixed = fixedCheckbox.isChecked()
values = list(str(valueBox.text()).strip().split())
for i in range(count):
if i < len(values):
value = values[i]
else:
value = values[-1]
if attrType == partio.INT or attrType == partio.INDEXEDSTR:
values[i] = int(value)
elif attrType == partio.FLOAT or attrType == partio.VECTOR:
values[i] = float(value) # pylint:disable=R0204
else:
values[i] = 0.0 # pylint:disable=R0204
value = tuple(values)
self.data.addAttribute(name, attrType, count, fixed, value)
