def __init__(self, parent, cmd):
QtWidgets.QWidget.__init__(self, parent, Qt.Window)
self.setMinimumSize(400, 500)
self.cmd = cmd
self.model = QtGui.QStandardItemModel(self)
self.proxy_model = QtCoreModels.QSortFilterProxyModel(self)
self.proxy_model.setSourceModel(self.model)
self.setWindowTitle('PyMOL Advanced Settings')
layout = QtWidgets.QVBoxLayout(self)
self.setLayout(layout)
self.filter_le = QtWidgets.QLineEdit(self)
layout.addWidget(self.filter_le)
self.filter_le.setPlaceholderText("Filter")
self.filter_le.textChanged.connect(self.proxy_model.setFilterRegExp)
self.populateData()
self.table = QtWidgets.QTableView(self)
self.table.setModel(self.proxy_model)
layout.addWidget(self.table)
self.formatTable()
self.model.itemChanged.connect(self.itemChanged)
def __init__(self, label_text="Input", buttons=[]):
PyMod_form_item.__init__(self)
# Label.
self.label = QtWidgets.QLabel(label_text)
# Buttons.
self.input = QtWidgets.QVBoxLayout()
if not buttons:
raise ValueError("Please provide a list of button names")
if len(buttons) != len(set(buttons)):
raise ValueError("Please provide a non redundant list of buttons")
self.button_group = QtWidgets.QButtonGroup()
self.buttons_names = []
self.buttons_dict = {}
for button_name in buttons:
button = QtWidgets.QPushButton(button_name)
button.setCheckable(True)
self.input.addWidget(button)
self.buttons_names.append(button_name)
self.buttons_dict[button_name] = button
self.button_group.addButton(button)
def initUI(self):
self.setWindowTitle(self.title)
vertical_layout = QtWidgets.QVBoxLayout()
self.thread_progressbar = QtWidgets.QProgressBar(self)
if self.progress:
self.thread_progressbar.setMinimum(0)
self.thread_progressbar.setMaximum(0)
progressbar_label = "Computing..." # "Wait for the protocol to complete."
self.thread_progressbar.setFormat(progressbar_label)
self.thread_progressbar.setValue(0)
vertical_layout.addWidget(self.thread_progressbar)
self.thread_progress_label = QtWidgets.QLabel(self.label_text, self)
self.thread_progress_label.setWordWrap(True)
vertical_layout.addWidget(self.thread_progress_label)
# Button for canceling the execution of the thread.
horizontal_layout = QtWidgets.QHBoxLayout()
self.cancel_button = QtWidgets.QPushButton('Cancel', self)
self.cancel_button.clicked.connect(self.on_cancel_button_click)
self.cancel_button.setEnabled(not self.lock)
horizontal_layout.addWidget(self.cancel_button)
vertical_layout.addLayout(horizontal_layout)
self.setLayout(vertical_layout)
def create_label_row(self):
"""
Row with two labels and a "Remove" button.
"""
# Create a first residue label that tells which residue has been selected.
self.res1_label = QtWidgets.QLabel(self.text1)
self.res1_label.setStyleSheet(small_font_style)
self.res1_label.setAlignment(QtCore.Qt.AlignCenter)
self.parent.loop_selector_frame_layout.addWidget(
self.res1_label, self.row, 0)
# Second residue label.
self.res2_label = QtWidgets.QLabel(self.text2)
self.res2_label.setStyleSheet(small_font_style)
self.res2_label.setAlignment(QtCore.Qt.AlignCenter)
self.parent.loop_selector_frame_layout.addWidget(
self.res2_label, self.row, 1)
# Adds the "Remove" button.
self.remove_loop_button = QtWidgets.QPushButton("Remove")
self.remove_loop_button.setStyleSheet(small_font_style)
self.remove_loop_button.clicked.connect(self.press_remove_button)
self.parent.loop_selector_frame_layout.addWidget(
self.remove_loop_button, self.row, 2)
def load_form(self, name, dialog=None):
'''Load a form from pmg_qt/forms/{name}.py'''
import importlib
if dialog is None:
dialog = QtWidgets.QDialog(self)
widget = dialog
elif dialog == 'floating':
widget = QtWidgets.QWidget(self)
else:
widget = dialog
try:
m = importlib.import_module('.forms.' + name, 'pmg_qt')
except ImportError as e:
if pymol.Qt.DEBUG:
print('load_form import failed (%s)' % (e, ))
uifile = os.path.join(os.path.dirname(__file__), 'forms',
'%s.ui' % name)
form = pymol.Qt.utils.loadUi(uifile, widget)
else:
if hasattr(m, 'Ui_Form'):
form = m.Ui_Form()
else:
form = m.Ui_Dialog()
form.setupUi(widget)
if dialog == 'floating':
dialog = QtWidgets.QDockWidget(widget.windowTitle(), self)
dialog.setFloating(True)
dialog.setWidget(widget)
dialog.resize(widget.size())
form._dialog = dialog
return form
def build_modeling_protocol_main_page(self):
"""
Starts to insert content in the "Main" page.
"""
# Builds a frame for each modeling_cluster.
for (i, modeling_cluster) in enumerate(
self.protocol.modeling_clusters_list):
# Add a spacer to separate the sections for each modeling cluster.
if i != 0 and self.protocol.multiple_chain_mode:
spacer_frame = QtWidgets.QFrame()
spacer_frame.setFrameShape(QtWidgets.QFrame.HLine)
spacer_frame.setFrameShadow(QtWidgets.QFrame.Sunken)
self.main_page_interior_layout.addRow(spacer_frame)
show_symmetry_restraints_option = False
# Widgets necessary to choose the templates for a single target sequence.
modeling_option_label = QtWidgets.QLabel(
"Modeling options for target: %s" %
(modeling_cluster.target_name))
modeling_option_label.setStyleSheet(modeling_window_title_style)
self.main_page_interior_layout.addRow(modeling_option_label)
if self.protocol.multiple_chain_mode:
# Use symmetry restraints option.
if modeling_cluster.symmetry_restraints_id != None:
show_symmetry_restraints_option = True
symmetry_checkbox, symmetry_info = self.build_symmetry_restraints_option(
modeling_cluster)
if any((show_symmetry_restraints_option,
)): # This might include other flags in future releases.
additional_options_label = QtWidgets.QLabel(
"Restraints options")
additional_options_label.setStyleSheet(
modeling_options_sections_style)
self.main_page_interior_layout.addRow(additional_options_label)
if show_symmetry_restraints_option:
self.main_page_interior_layout.addRow(
symmetry_checkbox, symmetry_info)
# Build a series of widgets for loop ranges selection.
modeling_option_label = QtWidgets.QLabel("Loop selection")
modeling_option_label.setStyleSheet(
modeling_options_sections_style)
self.main_page_interior_layout.addRow(modeling_option_label)
# Build a 'User_loop_selector_frame' object, which will contain information about
# user-defined loops for this target.
uls = User_loop_selector_frame_qt(
parent=None,
parent_window=self,
modeling_cluster=modeling_cluster)
modeling_cluster.user_loop_selector_frame = uls
self.main_page_interior_layout.addRow(uls)
def __init__(
self,
label_text="New scalebar",
slider_value=1,
slider_from=1,
slider_to=10,
slider_resoution=1,
# slider_digits=3,
slider_tickinterval=1,
slider_use_float=False,
slider_use_float_val=100.0,
slider_binding=None,
slider_width=None):
PyMod_form_item.__init__(self)
# Label.
self.label = QtWidgets.QLabel(label_text)
# Layout for the input widget and its label.
self.input = QtWidgets.QHBoxLayout()
# Adds a slider.
self.slider = QtWidgets.QSlider()
self.slider.setOrientation(QtCore.Qt.Horizontal)
self.slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
self.slider_use_float = slider_use_float
self.slider_use_float_val = slider_use_float_val
self.slider.slider_resoution = slider_resoution
self.slider.setMinimum(self._get_slider_val(slider_from,
internal=True))
self.slider.setMaximum(self._get_slider_val(slider_to, internal=True))
self.slider.setValue(self._get_slider_val(slider_value, internal=True))
self.slider.setTickInterval(
self._get_slider_val(slider_tickinterval, internal=True))
self.slider.setSingleStep(
self._get_slider_val(slider_resoution, internal=True))
self.slider.setPageStep(
self._get_slider_val(slider_tickinterval, internal=True))
self.slider.valueChanged.connect(self._on_slider_change)
self.slider.sliderPressed.connect(self._on_slider_pressed)
self.slider.sliderReleased.connect(self._on_slider_release)
self.on_drag = False
self.input.addWidget(self.slider)
# Add a label on the right of the slider.
self.slider_label = QtWidgets.QLabel(str(slider_to))
self.input.addWidget(self.slider_label)
if slider_width:
self.slider.setFixedWidth(slider_width)
self.slider_label.setFixedWidth(
self.slider_label.sizeHint().width())
self.slider_label.setText(str(slider_value))
self.slider_binding = slider_binding
def show_advanced_button(self):
self.advance_options_button = QtWidgets.QPushButton(
"Show Advanced Options")
self.advance_options_button.clicked.connect(
self.toggle_advanced_options)
self._advanced_options_label = QtWidgets.QLabel("")
self.middle_formlayout.addRow(self.advance_options_button,
self._advanced_options_label)
def __init__(self, label_text="Input"):
PyMod_form_item.__init__(self)
# Label.
self.label = QtWidgets.QLabel(label_text)
# Hbox.
self.hbox = QtWidgets.QHBoxLayout()
self.input = self.hbox
def initUI(self):
self.loop_selector_frame_layout = QtWidgets.QGridLayout()
self.setLayout(self.loop_selector_frame_layout)
label_text = "Select two residues for a loop"
self.modeling_cluster_loop_selection_label = QtWidgets.QLabel(
label_text)
self.modeling_cluster_loop_selection_label.setStyleSheet(
modeling_options_subsections_style)
self.loop_selector_frame_layout.addWidget(
self.modeling_cluster_loop_selection_label, 0, 0, 1, 3)
def __init__(self, label_text="Input", value=""):
PyMod_form_item.__init__(self)
# Label.
self.label = QtWidgets.QLabel(label_text)
# Second Entry.
self.right_label = QtWidgets.QLabel(value)
self.right_label.setWordWrap(True)
self.input = self.right_label
def add_line(label, text):
row = table.rowCount()
table.insertRow(table.rowCount())
table_item = QtWidgets.QTableWidgetItem(label)
table_item.setFlags(table_item.flags() &
~(Qt.ItemIsEditable))
table.setItem(row, 0, table_item)
table_item = QtWidgets.QTableWidgetItem(text)
table_item.setFlags(table_item.flags() &
~(Qt.ItemIsEditable))
table.setItem(row, 1, table_item)
def VolumePanelDocked(parent, *args, **kwargs):
widget = QtWidgets.QWidget(parent)
window = QtWidgets.QDockWidget(parent)
_VolumePanel(widget, window, *args, **kwargs)
window.setWidget(widget)
parent.addDockWidget(Qt.BottomDockWidgetArea, window)
# disabled: always use default style
# window.topLevelChanged.connect(widget.editor.windowTopLevelChanged)
return window
def build_alignment_mode_frame(self):
"""
Builds a frame with some options to choose the alignment mode.
"""
# Vbox which will store all the widgets for the alignment mode options.
self.alignment_mode_vbox = QtWidgets.QVBoxLayout()
self.alignment_mode_label = QtWidgets.QLabel("Alignment Mode")
self.alignment_mode_vbox.addWidget(self.alignment_mode_label)
self.alignment_mode_button_group = QtWidgets.QButtonGroup()
self.build_strategy_specific_modes_frames() # Defined in child classes.
self.middle_formlayout.addRow(self.alignment_mode_vbox)
def draw_table(headers=headers):
"""Fill the whole table with data from docked entries"""
widget.tableDocked.clear()
widget.tableDocked.setSortingEnabled(False)
n_internal_columns = 3
# check if requested headers in remarks
headers = [i for i in headers if i in docked.remarks]
# number of rows and columns
widget.tableDocked.setColumnCount(len(headers) + n_internal_columns)
widget.tableDocked.setRowCount(docked.n_entries)
# fill table
widget.tableDocked.setHorizontalHeaderLabels([""] *
n_internal_columns +
headers)
for row, entry in enumerate(docked.entries):
# hidden internal columns [n_entry, 'object', 'state']
widget.tableDocked.setItem(row, 0,
QtWidgets.QTableWidgetItem(str(row)))
widget.tableDocked.setItem(
row, 1,
QtWidgets.QTableWidgetItem(str(entry['internal']['object'])))
widget.tableDocked.setItem(
row, 2,
QtWidgets.QTableWidgetItem(str(entry['internal']['state'])))
# assign to table cell
for column, remark in enumerate(headers):
value = entry['remarks'][remark]
item = QtWidgets.QTableWidgetItem()
item.setData(QtCore.Qt.EditRole, value)
widget.tableDocked.setItem(row, column + n_internal_columns,
item)
widget.tableDocked.item(row, column +
n_internal_columns).setTextAlignment(
QtCore.Qt.AlignCenter)
widget.tableDocked.resizeColumnsToContents()
widget.tableDocked.resizeRowsToContents()
for i in range(n_internal_columns):
widget.tableDocked.hideColumn(i)
# update columns menubar
show_column.clear()
hide_column.clear()
for i in sorted(docked.remarks - set(headers)):
action = show_column.addAction(i)
action.triggered.connect(lambda chk, i=i: show_header(i))
for i in headers:
action = hide_column.addAction(i)
action.triggered.connect(lambda chk, i=i: hide_header(i))
# show table
widget.tableDocked.setSortingEnabled(True)
widget.tableDocked.show()
def _addmenu(data, menu):
'''Fill a menu from "data"'''
menu.setTearOffEnabled(True)
menu.setWindowTitle(menu.title()) # needed for Windows
for item in data:
if item[0] == 'separator':
menu.addSeparator()
elif item[0] == 'menu':
_addmenu(item[2], menu.addMenu(item[1].replace('&', '&&')))
elif item[0] == 'command':
command = item[2]
if command is None:
print('warning: skipping', item)
else:
if isinstance(command, str):
command = lambda c=command: cmd.do(c)
menu.addAction(item[1], command)
elif item[0] == 'check':
if len(item) > 4:
menu.addAction(
SettingAction(self, cmd, item[2], item[1], item[3],
item[4]))
else:
menu.addAction(
SettingAction(self, cmd, item[2], item[1]))
elif item[0] == 'radio':
label, name, value = item[1:4]
try:
group, type_, values = actiongroups[item[2]]
except KeyError:
group = QtWidgets.QActionGroup(self)
type_, values = cmd.get_setting_tuple(name)
actiongroups[item[2]] = group, type_, values
action = QtWidgets.QAction(label, self)
action.triggered.connect(lambda _=0, args=(name, value):
cmd.set(*args, log=1, quiet=0))
self.setting_callbacks[cmd.setting._get_index(
name)].append(
lambda v, V=value, a=action: a.setChecked(v == V))
group.addAction(action)
menu.addAction(action)
action.setCheckable(True)
if values[0] == value:
action.setChecked(True)
elif item[0] == 'open_recent_menu':
self.open_recent_menu = menu.addMenu('Open Recent...')
else:
print('error:', item)
def build_protocol_middle_frame(self):
"""
Allow to choose between plotting all amino acids types or only a subset
of them.
"""
# Radioselect.
aa_select_choices = ("Use all amino acids", "Select amino acids types")
aa_select_choices_values = ["all", "single"]
self.aa_select_choices_dict = dict([
(k, v)
for (k, v) in zip(aa_select_choices, aa_select_choices_values)
])
self.aa_select_rds = PyMod_radioselect_qt(
label_text="Select Amino Acids", buttons=aa_select_choices)
self.aa_select_rds.setvalue(aa_select_choices[0])
self.aa_select_rds.buttons_dict[aa_select_choices[0]].clicked.connect(
self.hide_select_single_aa_frame)
self.aa_select_rds.buttons_dict[aa_select_choices[1]].clicked.connect(
self.show_select_single_aa_frame)
self.middle_formlayout.add_widget_to_align(self.aa_select_rds)
# Checkboxes for selecting single amino acids.
self.aa_select_grid_layout = QtWidgets.QGridLayout()
self.aa_select_rds.input.addLayout(self.aa_select_grid_layout)
self.aa_checkbutton = {}
self.aa_freq_dict = {}
self.aa_checkbutton_list = []
for i, aa in enumerate(prot_standard_one_letter):
# Get the number of aa in the sequence.
aa_freq = str(self.protocol.target_sequence.my_sequence).count(aa)
self.aa_freq_dict[aa] = aa_freq
# Build a checkbox for the aa.
checkbox = QtWidgets.QCheckBox(
pmsm.one2three(aa) + " (" + str(aa_freq) + ")")
checkbox.setEnabled(False)
self.aa_select_grid_layout.addWidget(checkbox, int(i % 10),
int(i / 10))
self.aa_checkbutton[aa] = checkbox
self.aa_checkbutton_list.append(checkbox)
self.aa_select_grid_layout.setAlignment(QtCore.Qt.AlignLeft)
self.middle_formlayout.set_input_widgets_width("auto", padding=40)
def create_dialog():
dialog = QtWidgets.QDialog()
dialog.setWindowTitle('AlignIt Pymol plugin')
layout = QtWidgets.QVBoxLayout(dialog)
alignit = AlignItPlugin()
actions = {
'Read pharmacophore...': lambda: alignit.readAlignIt(dialog),
}
for name, action in actions.items():
btn = QtWidgets.QPushButton(name, dialog)
btn.pressed.connect(action)
layout.addWidget(btn)
return dialog
def _fill_list(self):
"""
Create the list's data.
"""
self.items_dict = {}
# Checks the database log in order to obtain the date when each database was last downloaded.
download_log_dict = {}
if os.path.isfile(self.installer_protocol.download_log_filepath):
with open(self.installer_protocol.download_log_filepath, "r") as l_fh:
download_log_dict = json.loads(l_fh.read())
# Configure the list of items is the 'all_components_list' from the PyMod Installer class.
self.view.setRowCount(len(self.installer_protocol.components_list))
for row_counter, component in enumerate(self.installer_protocol.components_list):
# Create an item and set the component name as text.
item = QtWidgets.QTableWidgetItem(component.full_name)
# add a checkbox to the name
item.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled)
item.setCheckState(QtCore.Qt.Unchecked)
# place the items in columns
self.view.setItem(row_counter, self.component_col_idx, item)
self.items_dict.update({component: item})
# Set the names of the databases.
self.view.setItem(row_counter, self.databases_col_idx, QtWidgets.QTableWidgetItem(component.databases_string))
# Create another item displaying the status.
graphic_status = 'Wait...'
status = QtWidgets.QTableWidgetItem(graphic_status)
status.setForeground(QtGui.QBrush(QtGui.QColor(191, 191, 191)))
self.view.setItem(row_counter, self.status_col_idx, status)
# Set the source URL.
self.view.setItem(row_counter, self.source_col_idx, QtWidgets.QTableWidgetItem(component.remote_source))
# Fill in the last downloaded column.
if component.name in download_log_dict:
last_downloaded_str = download_log_dict[component.name]
else:
last_downloaded_str = "Never"
last_downloaded_item = QtWidgets.QTableWidgetItem(last_downloaded_str)
self.view.setItem(row_counter, self.last_download_col_idx, last_downloaded_item)
self.items_status_dict[component.name] = status
self.items_last_download_dict[component.name] = last_downloaded_item
def build_selection_structure_menu(self):
self.selection_structure_context_submenu = QtWidgets.QMenu(
'Structures', self.selection_context_submenu)
self.selection_context_submenu.addMenu(
self.selection_structure_context_submenu)
if self.parent_group.pymod.all_sequences_have_structure():
add_qt_menu_command(
self.selection_structure_context_submenu,
"Show chains in PyMOL",
self.show_selected_chains_in_pymol_from_popup_menu)
add_qt_menu_command(
self.selection_structure_context_submenu,
"Hide chains in PyMOL",
self.hide_selected_chains_in_pymol_from_popup_menu)
self.selection_structure_context_submenu.addSeparator()
add_qt_menu_command(
self.selection_structure_context_submenu,
"Show Chains as Hedgehog",
self.show_hedgehog_chains_in_pymol_from_popup_menu)
add_qt_menu_command(self.selection_structure_context_submenu,
"Show Heteroatoms",
self.show_het_chains_in_pymol_from_popup_menu)
add_qt_menu_command(self.selection_structure_context_submenu,
"Hide Heteroatoms",
self.hide_het_chains_in_pymol_from_popup_menu)
elif self.parent_group.pymod.all_sequences_have_fetchable_pdbs():
add_qt_menu_command(
self.selection_structure_context_submenu, "Fetch PDB Files",
lambda: self.parent_group.pymod.fetch_pdb_files(
"selection", None))
def make_cat(parent, label):
item = QtWidgets.QTreeWidgetItem(parent)
item.setText(0, str(label))
item.setFirstColumnSpanned(True)
item.setExpanded(True)
item.setChildIndicatorPolicy(QtWidgets.QTreeWidgetItem.ShowIndicator)
return item
def pyvol_window():
""" """
from pymol.Qt.utils import loadUi
dialog = QtWidgets.QDialog()
uifile = os.path.join(os.path.dirname(__file__), 'pyvol_gui.ui')
form = loadUi(uifile, dialog)
refresh_installation_status(form)
form.close_button.clicked.connect(dialog.close)
form.run_button.clicked.connect(lambda: run_gui_pyvol(form))
form.browse_button.clicked.connect(lambda: browse_pocket_file(form))
form.load_button.clicked.connect(lambda: run_gui_load(form))
form.install_remote_button.clicked.connect(
lambda: install_remote_pyvol(form))
form.install_cache_button.clicked.connect(
lambda: install_local_pyvol(form))
form.check_updates_button.clicked.connect(
lambda: refresh_installation_status(form, check_for_updates=True))
form.update_button.clicked.connect(lambda: update_pyvol(form))
form.msms_included_cbox.stateChanged.connect(
lambda: toggle_included_msms(form))
dialog.show()
def add_plugin_item(info):
item = window.load_form('pluginitem', QtWidgets.QFrame())
item._widget = item._dialog
item._widget.setFrameStyle(QtWidgets.QFrame.Sunken)
item._widget.setFrameShape(QtWidgets.QFrame.Panel)
item.w_title.setText(info.name)
item.w_version.setText(info.get_version())
item.w_startup.setChecked(info.autoload)
item.w_startup.stateChanged.connect(self.w_startup_changed)
item.w_enable.pressed.connect(info.load)
item.w_enable.pressed.connect(self.disable_load_button)
item.w_uninstall.pressed.connect(info.uninstall)
item.w_uninstall.pressed.connect(self.reload_plugins)
if info.loaded:
item.w_enable.setEnabled(False)
if hasattr(info.module, 'settings_dialog'):
item.w_settings.setVisible(True)
else:
item.w_settings.setVisible(False)
item.w_info.pressed.connect(self.show_info)
if info.loadtime:
item.w_loadtime.setText("Took %.3f seconds to load" % info.loadtime)
else:
item.w_loadtime.setText("Not loaded")
item._widget._form = item
self.plugin_info[item] = info
self.form.f_installed_layout.addWidget(item._widget)
def build_models_submenu(self):
"""
Build an "Modeling Session n" voice in the "Models" submenu once some models have been
built.
"""
# Delete the old models submenu.
self.models_menu.clear()
if self.pymod.modeling_session_list != []:
for modeling_session in self.pymod.modeling_session_list:
# Adds a modeling session submenu to the PyMod main menu.
label_text = "Modeling Session %s" % (
modeling_session.session_id)
modeling_session_submenu = QtWidgets.QMenu(label_text, self)
self.models_menu.addMenu(modeling_session_submenu)
add_qt_menu_command(modeling_session_submenu,
"Export to File",
lambda a=None, ms=modeling_session: self.
pymod.save_modeling_session(ms))
add_qt_menu_command(modeling_session_submenu,
"DOPE Profile",
lambda a=None, ms=modeling_session: self.
pymod.show_session_profile(ms))
add_qt_menu_command(modeling_session_submenu,
"Assessment Table",
lambda a=None, ms=modeling_session: self.
pymod.show_assessment_table(ms))
else:
add_qt_menu_command(self.models_menu, "There aren't any models")
def BuilderPanelDocked(parent, *args, **kwargs):
widget = _BuilderPanel(parent, *args, **kwargs)
window = QtWidgets.QDockWidget(parent)
window.setWindowTitle("Builder")
window.setWidget(widget)
window.setFloating(True)
return window
def display_options(self, single_tool):
"""
Displays at list of option in the the target_frame contained in a target widget.
Used in the PyMod options window.
"""
# Check that at least one parameter
if not any([p.show_widget for p in single_tool.parameters]):
return None
self.tools_params_dict[single_tool.name] = {}
# Grids a label with the name of the tool.
tool_full_name_label = QtWidgets.QLabel(single_tool.full_name)
tool_full_name_label.setStyleSheet(options_title_style)
# print(dir(tool_full_name_label))
# print(tool_full_name_label.font().size())
self.middle_formlayout.addWidget(tool_full_name_label,
self.row_counter, 0)
self.row_counter += 1
# Actually grids the parmater widgets.
for parameter in single_tool.parameters:
if not parameter.show_widget:
continue
# If the display options return a widget, adds it ot the Tool list of parameter widgets.
w = self.display_paramenter_options(parameter)
self.row_counter += 1
def __init__(self,
label_text="Input",
value="",
readonly=False,
style=None,
enter_command=None,
validate={}):
PyMod_form_item.__init__(self)
# Label.
self.label = QtWidgets.QLabel(label_text)
# Entry.
self.entry = PyMod_entry_qt(value)
self.enter_command = enter_command
if self.enter_command is not None:
self.entry.returnPressed.connect(self.enter_command)
if readonly:
self.entry.setReadOnly(True)
if style is not None:
self.entry.setStyleSheet(style)
else:
self.entry.setStyleSheet(active_entry_style)
self.validate = validate
if self.validate:
self.entry.set_pmw_validator(self.validate)
self.input = self.entry
def make_entry(parent, label):
item = QtWidgets.QTreeWidgetItem(parent)
item.setText(0, str(label))
item.setFlags(QtCore.Qt.ItemIsEditable |
QtCore.Qt.ItemIsEnabled |
QtCore.Qt.ItemIsSelectable )
return item
def __init__(self):
from pymol.Qt import QtWidgets
dialog = QtWidgets.QDialog()
self.setupUi(dialog)
self.populate_ligand_select_list()
dialog.accepted.connect(self.accept)
dialog.exec_()
def askyesno_qt(title, message, parent=None, buttons_text=None):
"""
Wrapper to a Yes/no dialog in PyQt. If 'buttons_text' is 'None', the default
"Yes" and "No" buttons will be used. If 'buttons_text' is a list with two
strings, the first string will be the text of the "Yes" button and the second
one will be the text of the "No" button.
"""
# Use yes and no buttons.
if buttons_text is None:
answer = QtWidgets.QMessageBox.question(parent, title, message,
QtWidgets.QMessageBox.Yes,
QtWidgets.QMessageBox.No)
return answer == QtWidgets.QMessageBox.Yes
# Set custom text on the buttons.
else:
dialog = QtWidgets.QMessageBox(parent)
dialog.setWindowTitle(title)
dialog.setText(message)
yesbutton = dialog.addButton(buttons_text[0],
QtWidgets.QMessageBox.YesRole)
nobutton = dialog.addButton(buttons_text[1],
QtWidgets.QMessageBox.NoRole)
answer = dialog.exec_()
return dialog.clickedButton() is yesbutton
