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