class AcceptFiles(QDialog): def __init__(self, files): super().__init__() self.ok = QPushButton("Add", self) self.ok.clicked.connect(self.accept) discard = QPushButton("Discard", self) discard.clicked.connect(self.close) self.files = QListWidget(self) self.files.setSelectionMode(QAbstractItemView.ExtendedSelection) for file_name in files: self.files.addItem(file_name) for i in range(self.files.count()): self.files.item(i).setSelected(True) self.ok.setDefault(True) self.ok.setAutoDefault(True) layout = QVBoxLayout() layout.addWidget(QLabel("Found {} files".format(len(files)))) layout.addWidget(self.files) butt_layout = QHBoxLayout() butt_layout.addWidget(discard) butt_layout.addStretch() butt_layout.addWidget(self.ok) layout.addLayout(butt_layout) self.setLayout(layout) def selection_changed(self): if self.files.selectedItems().count() == 0: self.ok.setDisabled(True) else: self.ok.setEnabled(True) def get_files(self): return [str(item.text()) for item in self.files.selectedItems()]
class PickChannelsDialog(QDialog): def __init__(self, parent, channels, selected=None, title="Pick channels"): super().__init__(parent) self.setWindowTitle(title) if selected is None: selected = [] self.initial_selection = selected vbox = QVBoxLayout(self) self.channels = QListWidget() self.channels.insertItems(0, channels) self.channels.setSelectionMode(QListWidget.ExtendedSelection) for i in range(self.channels.count()): if self.channels.item(i).data(0) in selected: self.channels.item(i).setSelected(True) vbox.addWidget(self.channels) self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) vbox.addWidget(self.buttonbox) self.buttonbox.accepted.connect(self.accept) self.buttonbox.rejected.connect(self.reject) self.channels.itemSelectionChanged.connect(self.toggle_buttons) self.toggle_buttons() # initialize OK button state @Slot() def toggle_buttons(self): """Toggle OK button. """ selected = [item.data(0) for item in self.channels.selectedItems()] if selected != self.initial_selection: self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True) else: self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
def __init__(self, row: int, widget: QListWidget, parent: Optional[QWidget] = None): super(DeleteStorage, self).__init__(parent) self.setText(f"Delete {{Mechanism: {widget.item(row).text()}}}") self.row = row self.widget = widget self.name = widget.item(row).text() self.mechanism = widget.item(row).expr
class MontageDialog(QDialog): def __init__(self, parent, montages, selected=None): super().__init__(parent) self.setWindowTitle("Set montage") vbox = QVBoxLayout(self) self.montages = QListWidget() self.montages.insertItems(0, montages) self.montages.setSelectionMode(QListWidget.SingleSelection) if selected is not None: for i in range(self.montages.count()): if self.montages.item(i).data(0) == selected: self.montages.item(i).setSelected(True) vbox.addWidget(self.montages) hbox = QHBoxLayout() self.view_button = QPushButton("View") self.view_button.clicked.connect(self.view_montage) hbox.addWidget(self.view_button) hbox.addStretch() self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) hbox.addWidget(self.buttonbox) vbox.addLayout(hbox) self.buttonbox.accepted.connect(self.accept) self.buttonbox.rejected.connect(self.reject) self.montages.itemSelectionChanged.connect(self.toggle_buttons) self.toggle_buttons() # initialize OK and View buttons state @Slot() def toggle_buttons(self): """Toggle OK and View buttons. """ if self.montages.selectedItems(): self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True) self.view_button.setEnabled(True) else: self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False) self.view_button.setEnabled(False) def view_montage(self): name = self.montages.selectedItems()[0].data(0) montage = make_standard_montage(name) fig = montage.plot(show_names=True, show=False) win = fig.canvas.manager.window win.setWindowModality(Qt.WindowModal) win.setWindowTitle("Montage") win.findChild(QStatusBar).hide() win.findChild(QToolBar).hide() fig.show()
def __init__(self, row: int, widget: QListWidget, parent: Optional[QWidget] = None): super(DeleteInput, self).__init__(parent) self.setText(f"Remove variable of {{Point{row}}}") self.item = widget.item(row) self.widget = widget
class AppendDialog(QDialog): def __init__(self, parent, compatibles, title="Append data"): super().__init__(parent) self.setWindowTitle(title) vbox = QVBoxLayout(self) grid = QGridLayout() grid.addWidget(QLabel("Source"), 0, 0, Qt.AlignCenter) grid.addWidget(QLabel("Destination"), 0, 2, Qt.AlignCenter) source = QListWidget(self) source.setAcceptDrops(True) source.setDragEnabled(True) source.setSelectionMode(QAbstractItemView.ExtendedSelection) source.setDefaultDropAction(Qt.DropAction.MoveAction) source.insertItems(0, [d["name"] for d in compatibles]) grid.addWidget(source, 1, 0) grid.addWidget(QLabel("->"), 1, 1, Qt.AlignHCenter) self.destination = QListWidget(self) self.destination.setAcceptDrops(True) self.destination.setDragEnabled(True) self.destination.setSelectionMode(QAbstractItemView.ExtendedSelection) self.destination.setDefaultDropAction(Qt.DropAction.MoveAction) grid.addWidget(self.destination, 1, 2) vbox.addLayout(grid) self.buttonbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.buttonbox.accepted.connect(self.accept) self.buttonbox.rejected.connect(self.reject) vbox.addWidget(self.buttonbox) vbox.setSizeConstraint(QVBoxLayout.SetFixedSize) self.destination.model().rowsInserted.connect(self.toggle_buttons) self.destination.model().rowsRemoved.connect(self.toggle_buttons) self.toggle_buttons() @property def names(self): names = [] for it in range(self.destination.count()): names.append(self.destination.item(it).text()) return names @Slot() def toggle_buttons(self): """Toggle OK button. """ if self.destination.count() > 0: self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(True) else: self.buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
def _setup_and_check(self, widget, data, title, readonly, **kwargs): """ Setup SessionComparator. Parameters ---------- widget: QWidget Parent widget. data: list or tuple of Session Sessions to compare. title: str Title. readonly: bool kwargs: * rtol: int or float * atol: int or float * nans_equal: bool * bg_gradient: str * names: list of str * colors: str """ sessions = data names = kwargs.get( 'names', ["Session{}".format(i) for i in range(len(sessions))]) assert all(isinstance(s, la.Session) for s in sessions) self.sessions = sessions self.stack_axis = la.Axis(names, 'session') layout = QVBoxLayout() widget.setLayout(layout) array_names = sorted( set.union(*[ set(s.filter(kind=DISPLAY_IN_GRID).names) for s in self.sessions ])) listwidget = QListWidget(self) listwidget.addItems(array_names) listwidget.currentItemChanged.connect(self.on_item_changed) for i, name in enumerate(array_names): arrays = self.get_arrays(name) first_array = arrays[0] if not all( a.equals(first_array, nans_equal=True) for a in arrays[1:]): listwidget.item(i).setForeground(Qt.red) self.listwidget = listwidget comparatorwidget = ComparatorWidget(self, **kwargs) self.arraywidget = comparatorwidget main_splitter = QSplitter(Qt.Horizontal) main_splitter.addWidget(listwidget) main_splitter.addWidget(comparatorwidget) main_splitter.setSizes([5, 95]) main_splitter.setCollapsible(1, False) self.widget_state_settings['main_splitter'] = main_splitter layout.addWidget(main_splitter) self.listwidget.setCurrentRow(0)
class ProgressView(QWidget): """ :type batch_manager: CalculationManager """ def __init__(self, parent, batch_manager): QWidget.__init__(self, parent) self.calculation_manager = batch_manager self.whole_progress = QProgressBar(self) self.whole_progress.setMinimum(0) self.whole_progress.setMaximum(1) self.whole_progress.setFormat("%v of %m") self.whole_progress.setTextVisible(True) self.part_progress = QProgressBar(self) self.part_progress.setMinimum(0) self.part_progress.setMaximum(1) self.part_progress.setFormat("%v of %m") self.whole_label = QLabel("All batch progress:", self) self.part_label = QLabel("Single batch progress:", self) self.logs = ExceptionList(self) self.logs.setToolTip("Logs") self.task_que = QListWidget() self.process_num_timer = QTimer() self.process_num_timer.setInterval(1000) self.process_num_timer.setSingleShot(True) self.process_num_timer.timeout.connect(self.change_number_of_workers) self.number_of_process = QSpinBox(self) self.number_of_process.setRange(1, multiprocessing.cpu_count()) self.number_of_process.setValue(1) self.number_of_process.setToolTip( "Number of process used in batch calculation") self.number_of_process.valueChanged.connect( self.process_num_timer_start) layout = QGridLayout() layout.addWidget(self.whole_label, 0, 0, Qt.AlignRight) layout.addWidget(self.whole_progress, 0, 1, 1, 2) layout.addWidget(self.part_label, 1, 0, Qt.AlignRight) layout.addWidget(self.part_progress, 1, 1, 1, 2) lab = QLabel("Number of process:") lab.setToolTip("Number of process used in batch calculation") layout.addWidget(lab, 2, 0) layout.addWidget(self.number_of_process, 2, 1) layout.addWidget(self.logs, 3, 0, 1, 3) layout.addWidget(self.task_que, 0, 4, 0, 1) layout.setColumnMinimumWidth(2, 10) layout.setColumnStretch(2, 1) self.setLayout(layout) self.preview_timer = QTimer() self.preview_timer.setInterval(1000) self.preview_timer.timeout.connect(self.update_info) def new_task(self): self.whole_progress.setMaximum( self.calculation_manager.calculation_size) if not self.preview_timer.isActive(): self.update_info() self.preview_timer.start() def update_info(self): res = self.calculation_manager.get_results() for el in res.errors: if el[0]: QListWidgetItem(el[0], self.logs) ExceptionListItem(el[1], self.logs) if (state_store.report_errors and parsed_version.is_devrelease and not isinstance(el[1][0], SegmentationLimitException) and isinstance(el[1][1], tuple)): with sentry_sdk.push_scope() as scope: scope.set_tag("auto_report", "true") sentry_sdk.capture_event(el[1][1][0]) self.whole_progress.setValue(res.global_counter) working_search = True for i, (progress, total) in enumerate(res.jobs_status): if working_search and progress != total: self.part_progress.setMaximum(total) self.part_progress.setValue(progress) working_search = False if i < self.task_que.count(): item = self.task_que.item(i) item.setText("Task {} ({}/{})".format(i, progress, total)) else: self.task_que.addItem("Task {} ({}/{})".format( i, progress, total)) if not self.calculation_manager.has_work: print( "[ProgressView.update_info]", self.calculation_manager.has_work, self.calculation_manager.batch_manager.has_work, self.calculation_manager.writer.writing_finished(), ) self.part_progress.setValue(self.part_progress.maximum()) self.preview_timer.stop() logging.info("Progress stop") def process_num_timer_start(self): self.process_num_timer.start() def update_progress(self, total_progress, part_progress): self.whole_progress.setValue(total_progress) self.part_progress.setValue(part_progress) def set_total_size(self, size): self.whole_progress.setMaximum(size) def set_part_size(self, size): self.part_progress.setMaximum(size) def change_number_of_workers(self): self.calculation_manager.set_number_of_workers( self.number_of_process.value())
class PayloadWindow(FramelessWindow): get_build_options = Signal() start_build = Signal(str, str, list) stop_build = Signal() def __init__(self, parent): super(PayloadWindow, self).__init__(parent) self.logger = logging.getLogger(self.__class__.__name__) self.setContentsMargins(11, 11, 11, 11) self.progress_windows = [] self.content_widget = QWidget(self) self.addContentWidget(self.content_widget) self.widget_layout = QFormLayout(self.content_widget) self.content_widget.setLayout(self.widget_layout) self.spinner = WaitingSpinner(self, modality=Qt.WindowModal, roundness=70.0, fade=70.0, radius=15.0, lines=6, line_length=25.0, line_width=4.0, speed=1.0) self.build_name_label = QLabel("Name", self.content_widget) self.build_name_edit = QLineEdit(self.content_widget) self.widget_layout.addRow(self.build_name_label, self.build_name_edit) self.icon_label = QLabel("Icon", self.content_widget) self.icon_combobox = QComboBox(self.content_widget) self.widget_layout.addRow(self.icon_label, self.icon_combobox) self.generators_label = QLabel("Generators", self.content_widget) self.generators_list = QListWidget(self.content_widget) self.widget_layout.addRow(self.generators_label, self.generators_list) self.build_button = QPushButton("Build", self.content_widget) self.build_button.clicked.connect(self.on_build_button_clicked) self.widget_layout.addWidget(self.build_button) self.menu = QMenu(self) self.menu.setTitle("Payload") self.reload_action = QAction(self.menu) self.reload_action.setText("Reload options") self.reload_action.triggered.connect(self.setupUi) self.menu.addAction(self.reload_action) self.addMenu(self.menu) @Slot() def setupUi(self): self.spinner.start() self.get_build_options.emit() @Slot(dict) def process_build_message(self, message): if self.isVisible(): event = message.get("event") if event == "options": options = message.get("options") self.set_options(options.get("generators"), options.get("icons")) elif event == "started": self.set_started(message.get("generator_name")) elif event == "stopped": self.set_stopped() elif event == "progress": self.set_progress(message.get("generator_name"), message.get("progress")) elif event == "error": self.set_error(message.get("error")) elif event == "generator_finished": self.set_generator_finished(message.get("generator_name"), message.get("exit_code")) elif event == "build_finished": self.set_build_finished() @Slot(str, str) def set_progress(self, generator_name, progress): for win in self.progress_windows: if win.generator() == generator_name: win.appendProgress(progress) @Slot(str) def set_started(self, generator_name): win = ProgressWindow(self, generator_name) win.show() self.progress_windows.append(win) self.logger.info("Generator {} started!".format(generator_name)) self.reload_action.setEnabled(False) self.spinner.start() @Slot(str, int) def set_generator_finished(self, generator_name, exit_code): self.logger.info("Generator {} finished with exit code {}.".format( generator_name, exit_code)) @Slot(list, list) def set_options(self, generators, icons): self.build_name_edit.clear() self.generators_list.clear() self.icon_combobox.clear() for generator in generators: item = QListWidgetItem(generator, self.generators_list) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Checked) self.generators_list.addItem(item) for icon in icons: name = icon.get("name") pix = QPixmap() pix.loadFromData(base64.b64decode(icon.get("ico"))) ico = QIcon() ico.addPixmap(pix) self.icon_combobox.addItem(ico, name) self.spinner.stop() @Slot() def set_stopped(self): self.on_build_finished() self.build_button.setText("Build") self.stopped_messagebox = FramelessInformationMessageBox(self) self.stopped_messagebox.setText( "Build process has been stopped successfully.") self.stopped_messagebox.setStandardButtons(QDialogButtonBox.Ok) self.stopped_messagebox.button(QDialogButtonBox.Ok).clicked.connect( self.stopped_messagebox.close) self.stopped_messagebox.show() @Slot(str) def set_error(self, error): self.on_build_finished() self.build_button.setText("Build") self.error_messagebox = FramelessCriticalMessageBox(self) self.error_messagebox.setText(error) self.error_messagebox.setStandardButtons(QDialogButtonBox.Ok) self.error_messagebox.button(QDialogButtonBox.Ok).clicked.connect( self.error_messagebox.close) self.error_messagebox.show() @Slot() def set_build_finished(self): self.on_build_finished() self.build_button.setText("Build") self.build_finished_messagebox = FramelessInformationMessageBox(self) self.build_finished_messagebox.setText( "Build process has been finished.") self.build_finished_messagebox.setStandardButtons(QDialogButtonBox.Ok) self.build_finished_messagebox.button( QDialogButtonBox.Ok).clicked.connect( self.build_finished_messagebox.close) self.build_finished_messagebox.show() @Slot() def on_build_button_clicked(self): if self.build_button.text() == "Build": generators = [] for i in range(self.generators_list.count()): item = self.generators_list.item(i) if item.checkState() == Qt.Checked: generators.append(item.text()) self.start_build.emit(self.build_name_edit.text(), self.icon_combobox.currentText(), generators) self.build_button.setText("Stop") else: self.stop_build_messagebox = FramelessQuestionMessageBox(self) self.stop_build_messagebox.setText( "Do you want to stop build process?") self.stop_build_messagebox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.stop_build_messagebox.button( QDialogButtonBox.Cancel).clicked.connect( self.stop_build_messagebox.close) self.stop_build_messagebox.button( QDialogButtonBox.Ok).clicked.connect(self.stop_build.emit) self.stop_build_messagebox.button( QDialogButtonBox.Ok).clicked.connect( self.stop_build_messagebox.close) self.stop_build_messagebox.show() @Slot() def on_build_finished(self): self.reload_action.setEnabled(True) self.spinner.stop() @Slot() def close(self) -> bool: for win in self.progress_windows: win.close() return super().close()
class FileSwitcher(QDialog): """A Sublime-like file switcher.""" sig_goto_file = Signal(int, object) # Constants that define the mode in which the list widget is working # FILE_MODE is for a list of files, SYMBOL_MODE if for a list of symbols # in a given file when using the '@' symbol. FILE_MODE, SYMBOL_MODE = [1, 2] MAX_WIDTH = 600 def __init__(self, parent, plugin, tabs, data, icon): QDialog.__init__(self, parent) # Variables self.plugins_tabs = [] self.plugins_data = [] self.plugins_instances = [] self.add_plugin(plugin, tabs, data, icon) self.plugin = None # Last plugin with focus self.mode = self.FILE_MODE # By default start in this mode self.initial_cursors = None # {fullpath: QCursor} self.initial_path = None # Fullpath of initial active editor self.initial_widget = None # Initial active editor self.line_number = None # Selected line number in filer self.is_visible = False # Is the switcher visible? help_text = _("Press <b>Enter</b> to switch files or <b>Esc</b> to " "cancel.<br><br>Type to filter filenames.<br><br>" "Use <b>:number</b> to go to a line, e.g. " "<b><code>main:42</code></b><br>" "Use <b>@symbol_text</b> to go to a symbol, e.g. " "<b><code>@init</code></b>" "<br><br> Press <b>Ctrl+W</b> to close current tab.<br>") # Either allow searching for a line number or a symbol but not both regex = QRegExp("([A-Za-z0-9_]{0,100}@[A-Za-z0-9_]{0,100})|" + "([A-Za-z0-9_]{0,100}:{0,1}[0-9]{0,100})") # Widgets self.edit = FilesFilterLine(self) self.help = HelperToolButton() self.list = QListWidget(self) self.filter = KeyPressFilter() regex_validator = QRegExpValidator(regex, self.edit) # Widgets setup self.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint) self.setWindowOpacity(0.95) self.edit.installEventFilter(self.filter) self.edit.setValidator(regex_validator) self.help.setToolTip(help_text) self.list.setItemDelegate(HTMLDelegate(self)) # Layout edit_layout = QHBoxLayout() edit_layout.addWidget(self.edit) edit_layout.addWidget(self.help) layout = QVBoxLayout() layout.addLayout(edit_layout) layout.addWidget(self.list) self.setLayout(layout) # Signals self.rejected.connect(self.restore_initial_state) self.filter.sig_up_key_pressed.connect(self.previous_row) self.filter.sig_down_key_pressed.connect(self.next_row) self.edit.returnPressed.connect(self.accept) self.edit.textChanged.connect(self.setup) self.list.itemSelectionChanged.connect(self.item_selection_changed) self.list.clicked.connect(self.edit.setFocus) # --- Properties @property def widgets(self): widgets = [] for plugin in self.plugins_instances: tabs = self.get_plugin_tabwidget(plugin) widgets += [(tabs.widget(index), plugin) for index in range(tabs.count())] return widgets @property def line_count(self): line_count = [] for widget in self.widgets: try: current_line_count = widget[0].get_line_count() except AttributeError: current_line_count = 0 line_count.append(current_line_count) return line_count @property def save_status(self): save_status = [] for da, icon in self.plugins_data: save_status += [getattr(td, 'newly_created', False) for td in da] return save_status @property def paths(self): paths = [] for plugin in self.plugins_instances: da = self.get_plugin_data(plugin) paths += [getattr(td, 'filename', None) for td in da] return paths @property def filenames(self): filenames = [] for plugin in self.plugins_instances: da = self.get_plugin_data(plugin) filenames += [ os.path.basename(getattr(td, 'filename', None)) for td in da ] return filenames @property def icons(self): icons = [] for da, icon in self.plugins_data: icons += [icon for td in da] return icons @property def current_path(self): return self.paths_by_widget[self.get_widget()] @property def paths_by_widget(self): widgets = [w[0] for w in self.widgets] return dict(zip(widgets, self.paths)) @property def widgets_by_path(self): widgets = [w[0] for w in self.widgets] return dict(zip(self.paths, widgets)) @property def filter_text(self): """Get the normalized (lowecase) content of the filter text.""" return to_text_string(self.edit.text()).lower() def set_search_text(self, _str): self.edit.setText(_str) def save_initial_state(self): """Save initial cursors and initial active widget.""" paths = self.paths self.initial_widget = self.get_widget() self.initial_cursors = {} for i, editor in enumerate(self.widgets): if editor is self.initial_widget: self.initial_path = paths[i] # This try is needed to make the fileswitcher work with # plugins that does not have a textCursor. try: self.initial_cursors[paths[i]] = editor.textCursor() except AttributeError: pass def accept(self): self.is_visible = False QDialog.accept(self) self.list.clear() def restore_initial_state(self): """Restores initial cursors and initial active editor.""" self.list.clear() self.is_visible = False widgets = self.widgets_by_path if not self.edit.clicked_outside: for path in self.initial_cursors: cursor = self.initial_cursors[path] if path in widgets: self.set_editor_cursor(widgets[path], cursor) if self.initial_widget in self.paths_by_widget: index = self.paths.index(self.initial_path) self.sig_goto_file.emit(index) def set_dialog_position(self): """Positions the file switcher dialog.""" parent = self.parent() geo = parent.geometry() width = self.list.width() # This has been set in setup left = parent.geometry().width() / 2 - width / 2 # Note: the +1 pixel on the top makes it look better if isinstance(parent, QMainWindow): top = (parent.toolbars_menu.geometry().height() + parent.menuBar().geometry().height() + 1) else: top = self.plugins_tabs[0][0].tabBar().geometry().height() + 1 while parent: geo = parent.geometry() top += geo.top() left += geo.left() parent = parent.parent() self.move(left, top) def get_item_size(self, content): """ Get the max size (width and height) for the elements of a list of strings as a QLabel. """ strings = [] if content: for rich_text in content: label = QLabel(rich_text) label.setTextFormat(Qt.PlainText) strings.append(label.text()) fm = label.fontMetrics() return (max([fm.width(s) * 1.3 for s in strings]), fm.height()) def fix_size(self, content): """ Adjusts the width and height of the file switcher based on the relative size of the parent and content. """ # Update size of dialog based on relative size of the parent if content: width, height = self.get_item_size(content) # Width parent = self.parent() relative_width = parent.geometry().width() * 0.65 if relative_width > self.MAX_WIDTH: relative_width = self.MAX_WIDTH self.list.setMinimumWidth(relative_width) # Height if len(content) < 8: max_entries = len(content) else: max_entries = 8 max_height = height * max_entries * 2.5 self.list.setMinimumHeight(max_height) # Resize self.list.resize(relative_width, self.list.height()) # --- Helper methods: List widget def count(self): """Gets the item count in the list widget.""" return self.list.count() def current_row(self): """Returns the current selected row in the list widget.""" return self.list.currentRow() def set_current_row(self, row): """Sets the current selected row in the list widget.""" return self.list.setCurrentRow(row) def select_row(self, steps): """Select row in list widget based on a number of steps with direction. Steps can be positive (next rows) or negative (previous rows). """ row = self.current_row() + steps if 0 <= row < self.count(): self.set_current_row(row) def previous_row(self): """Select previous row in list widget.""" if self.mode == self.SYMBOL_MODE: self.select_row(-1) return prev_row = self.current_row() - 1 if prev_row >= 0: title = self.list.item(prev_row).text() else: title = '' if prev_row == 0 and '</b></big><br>' in title: self.list.scrollToTop() elif '</b></big><br>' in title: # Select the next previous row, the one following is a title self.select_row(-2) else: self.select_row(-1) def next_row(self): """Select next row in list widget.""" if self.mode == self.SYMBOL_MODE: self.select_row(+1) return next_row = self.current_row() + 1 if next_row < self.count(): if '</b></big><br>' in self.list.item(next_row).text(): # Select the next next row, the one following is a title self.select_row(+2) else: self.select_row(+1) def get_stack_index(self, stack_index, plugin_index): """Get the real index of the selected item.""" other_plugins_count = sum([other_tabs[0].count() \ for other_tabs in \ self.plugins_tabs[:plugin_index]]) real_index = stack_index - other_plugins_count return real_index # --- Helper methods: Widget def get_plugin_data(self, plugin): """Get the data object of the plugin's current tab manager.""" # The data object is named "data" in the editor plugin while it is # named "clients" in the notebook plugin. try: data = plugin.get_current_tab_manager().data except AttributeError: data = plugin.get_current_tab_manager().clients return data def get_plugin_tabwidget(self, plugin): """Get the tabwidget of the plugin's current tab manager.""" # The tab widget is named "tabs" in the editor plugin while it is # named "tabwidget" in the notebook plugin. try: tabwidget = plugin.get_current_tab_manager().tabs except AttributeError: tabwidget = plugin.get_current_tab_manager().tabwidget return tabwidget def get_widget(self, index=None, path=None, tabs=None): """Get widget by index. If no tabs and index specified the current active widget is returned. """ if (index and tabs) or (path and tabs): return tabs.widget(index) elif self.plugin: return self.get_plugin_tabwidget(self.plugin).currentWidget() else: return self.plugins_tabs[0][0].currentWidget() def set_editor_cursor(self, editor, cursor): """Set the cursor of an editor.""" pos = cursor.position() anchor = cursor.anchor() new_cursor = QTextCursor() if pos == anchor: new_cursor.movePosition(pos) else: new_cursor.movePosition(anchor) new_cursor.movePosition(pos, QTextCursor.KeepAnchor) editor.setTextCursor(cursor) def goto_line(self, line_number): """Go to specified line number in current active editor.""" if line_number: line_number = int(line_number) try: self.plugin.go_to_line(line_number) except AttributeError: pass # --- Helper methods: Outline explorer def get_symbol_list(self): """Get the list of symbols present in the file.""" try: oedata = self.get_widget().get_outlineexplorer_data() except AttributeError: oedata = {} return oedata # --- Handlers def item_selection_changed(self): """List widget item selection change handler.""" row = self.current_row() if self.count() and row >= 0: if '</b></big><br>' in self.list.currentItem().text() and row == 0: self.next_row() if self.mode == self.FILE_MODE: try: stack_index = self.paths.index(self.filtered_path[row]) self.plugin = self.widgets[stack_index][1] plugin_index = self.plugins_instances.index(self.plugin) # Count the real index in the tabWidget of the # current plugin real_index = self.get_stack_index(stack_index, plugin_index) self.sig_goto_file.emit( real_index, self.plugin.get_current_tab_manager()) self.goto_line(self.line_number) try: self.plugin.switch_to_plugin() self.raise_() except AttributeError: # The widget using the fileswitcher is not a plugin pass self.edit.setFocus() except ValueError: pass else: line_number = self.filtered_symbol_lines[row] self.goto_line(line_number) def setup_file_list(self, filter_text, current_path): """Setup list widget content for file list display.""" short_paths = shorten_paths(self.paths, self.save_status) paths = self.paths icons = self.icons results = [] trying_for_line_number = ':' in filter_text # Get optional line number if trying_for_line_number: filter_text, line_number = filter_text.split(':') if line_number == '': line_number = None # Get all the available filenames scores = get_search_scores('', self.filenames, template="<b>{0}</b>") else: line_number = None # Get all available filenames and get the scores for # "fuzzy" matching scores = get_search_scores(filter_text, self.filenames, template="<b>{0}</b>") # Get max width to determine if shortpaths should be used max_width = self.get_item_size(paths)[0] self.fix_size(paths) # Build the text that will appear on the list widget for index, score in enumerate(scores): text, rich_text, score_value = score if score_value != -1: text_item = '<big>' + rich_text.replace('&', '') + '</big>' if trying_for_line_number: text_item += " [{0:} {1:}]".format(self.line_count[index], _("lines")) if max_width > self.list.width(): text_item += u"<br><i>{0:}</i>".format(short_paths[index]) else: text_item += u"<br><i>{0:}</i>".format(paths[index]) if (trying_for_line_number and self.line_count[index] != 0 or not trying_for_line_number): results.append((score_value, index, text_item)) # Sort the obtained scores and populate the list widget self.filtered_path = [] plugin = None for result in sorted(results): index = result[1] path = paths[index] icon = icons[index] text = '' try: title = self.widgets[index][1].get_plugin_title().split(' - ') if plugin != title[0]: plugin = title[0] text += '<br><big><b>' + plugin + '</b></big><br>' item = QListWidgetItem(text) item.setToolTip(path) item.setSizeHint(QSize(0, 25)) item.setFlags(Qt.ItemIsEditable) self.list.addItem(item) self.filtered_path.append(path) except: # The widget using the fileswitcher is not a plugin pass text = '' text += result[-1] item = QListWidgetItem(icon, text) item.setToolTip(path) item.setSizeHint(QSize(0, 25)) self.list.addItem(item) self.filtered_path.append(path) # To adjust the delegate layout for KDE themes self.list.files_list = True # Move selected item in list accordingly and update list size if current_path in self.filtered_path: self.set_current_row(self.filtered_path.index(current_path)) elif self.filtered_path: self.set_current_row(0) # If a line number is searched look for it self.line_number = line_number self.goto_line(line_number) def setup_symbol_list(self, filter_text, current_path): """Setup list widget content for symbol list display.""" # Get optional symbol name filter_text, symbol_text = filter_text.split('@') # Fetch the Outline explorer data, get the icons and values oedata = self.get_symbol_list() icons = get_python_symbol_icons(oedata) # The list of paths here is needed in order to have the same # point of measurement for the list widget size as in the file list # See issue 4648 paths = self.paths # Update list size self.fix_size(paths) symbol_list = process_python_symbol_data(oedata) line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list] choices = [item[1] for item in symbol_list] scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>") # Build the text that will appear on the list widget results = [] lines = [] self.filtered_symbol_lines = [] for index, score in enumerate(scores): text, rich_text, score_value = score line, fold_level, token = line_fold_token[index] lines.append(text) if score_value != -1: results.append((score_value, line, text, rich_text, fold_level, icons[index], token)) template = '{0}{1}' for (score, line, text, rich_text, fold_level, icon, token) in sorted(results): fold_space = ' ' * (fold_level) line_number = line + 1 self.filtered_symbol_lines.append(line_number) textline = template.format(fold_space, rich_text) item = QListWidgetItem(icon, textline) item.setSizeHint(QSize(0, 16)) self.list.addItem(item) # To adjust the delegate layout for KDE themes self.list.files_list = False # Select edit line when using symbol search initially. # See issue 5661 self.edit.setFocus() # Move selected item in list accordingly # NOTE: Doing this is causing two problems: # 1. It makes the cursor to auto-jump to the last selected # symbol after opening or closing a different file # 2. It moves the cursor to the first symbol by default, # which is very distracting. # That's why this line is commented! # self.set_current_row(0) def setup(self): """Setup list widget content.""" if len(self.plugins_tabs) == 0: self.close() return self.list.clear() current_path = self.current_path filter_text = self.filter_text # Get optional line or symbol to define mode and method handler trying_for_symbol = ('@' in self.filter_text) if trying_for_symbol: self.mode = self.SYMBOL_MODE self.setup_symbol_list(filter_text, current_path) else: self.mode = self.FILE_MODE self.setup_file_list(filter_text, current_path) # Set position according to size self.set_dialog_position() def show(self): """ Override Qt method to force an update of the fileswitcher before showing it. See Issue #5317 and PR #5389. """ self.setup() super(FileSwitcher, self).show() def add_plugin(self, plugin, tabs, data, icon): """Add a plugin to display its files.""" self.plugins_tabs.append((tabs, plugin)) self.plugins_data.append((data, icon)) self.plugins_instances.append(plugin)
class FileAssociationsWidget(QWidget): """Widget to add applications association to file extensions.""" # This allows validating a single extension entry or a list of comma # separated values (eg `*.json` or `*.json,*.txt,MANIFEST.in`) _EXTENSIONS_LIST_REGEX = (r'(?:(?:\*{1,1}|\w+)\.\w+)' r'(?:,(?:\*{1,1}|\w+)\.\w+){0,20}') sig_data_changed = Signal(dict) def __init__(self, parent=None): """Widget to add applications association to file extensions.""" super(FileAssociationsWidget, self).__init__(parent=parent) # Variables self._data = {} self._dlg_applications = None self._dlg_input = None self._regex = re.compile(self._EXTENSIONS_LIST_REGEX) # Widgets self.label = QLabel( _('Here you can associate which external applications you want' 'to use to open specific file extensions <br> (e.g. .txt ' 'files with Notepad++ or .csv files with Excel).')) self.label_extensions = QLabel(_('File types:')) self.list_extensions = QListWidget() self.button_add = QPushButton(_('Add')) self.button_remove = QPushButton(_('Remove')) self.button_edit = QPushButton(_('Edit')) self.label_applications = QLabel(_('Associated applications:')) self.list_applications = QListWidget() self.button_add_application = QPushButton(_('Add')) self.button_remove_application = QPushButton(_('Remove')) self.button_default = QPushButton(_('Set default')) # Layout layout_extensions = QHBoxLayout() layout_extensions.addWidget(self.list_extensions, 4) layout_buttons_extensions = QVBoxLayout() layout_buttons_extensions.addWidget(self.button_add) layout_buttons_extensions.addWidget(self.button_remove) layout_buttons_extensions.addWidget(self.button_edit) layout_buttons_extensions.addStretch() layout_applications = QHBoxLayout() layout_applications.addWidget(self.list_applications, 4) layout_buttons_applications = QVBoxLayout() layout_buttons_applications.addWidget(self.button_add_application) layout_buttons_applications.addWidget(self.button_remove_application) layout_buttons_applications.addWidget(self.button_default) layout_buttons_applications.addStretch() layout_extensions.addLayout(layout_buttons_extensions, 2) layout_applications.addLayout(layout_buttons_applications, 2) layout = QVBoxLayout() layout.addWidget(self.label) layout.addWidget(self.label_extensions) layout.addLayout(layout_extensions) layout.addWidget(self.label_applications) layout.addLayout(layout_applications) self.setLayout(layout) # Signals self.button_add.clicked.connect(lambda: self.add_association()) self.button_remove.clicked.connect(self.remove_association) self.button_edit.clicked.connect(self.edit_association) self.button_add_application.clicked.connect(self.add_application) self.button_remove_application.clicked.connect(self.remove_application) self.button_default.clicked.connect(self.set_default_application) self.list_extensions.currentRowChanged.connect(self.update_extensions) self.list_extensions.itemDoubleClicked.connect(self.edit_association) self.list_applications.currentRowChanged.connect( self.update_applications) self._refresh() self._create_association_dialog() def _refresh(self): """Refresh the status of buttons on widget.""" self.setUpdatesEnabled(False) for widget in [ self.button_remove, self.button_add_application, self.button_edit, self.button_remove_application, self.button_default ]: widget.setDisabled(True) item = self.list_extensions.currentItem() if item: for widget in [ self.button_remove, self.button_add_application, self.button_remove_application, self.button_edit ]: widget.setDisabled(False) self.update_applications() self.setUpdatesEnabled(True) def _add_association(self, value): """Add association helper.""" # Check value is not pressent for row in range(self.list_extensions.count()): item = self.list_extensions.item(row) if item.text().strip() == value.strip(): break else: item = QListWidgetItem(value) self.list_extensions.addItem(item) self.list_extensions.setCurrentItem(item) self._refresh() def _add_application(self, app_name, fpath): """Add application helper.""" app_not_found_text = _(' (Application not found!)') for row in range(self.list_applications.count()): item = self.list_applications.item(row) # Ensure the actual name is checked without the `app not found` # additional text, in case app was not found item_text = item.text().replace(app_not_found_text, '').strip() if item and item_text == app_name: break else: icon = get_application_icon(fpath) if not (os.path.isfile(fpath) or os.path.isdir(fpath)): app_name += app_not_found_text item = QListWidgetItem(icon, app_name) self.list_applications.addItem(item) self.list_applications.setCurrentItem(item) if not (os.path.isfile(fpath) or os.path.isdir(fpath)): item.setToolTip(_('Application not found!')) def _update_extensions(self): """Update extensions list.""" self.list_extensions.clear() for extension, _ in sorted(self._data.items()): self._add_association(extension) # Select first item self.list_extensions.setCurrentRow(0) self.update_extensions() self.update_applications() def _create_association_dialog(self): """Create input extension dialog and save it to for reuse.""" self._dlg_input = InputTextDialog( self, title=_('File association'), label=(_('Enter new file extension. You can add several values ' 'separated by commas.<br>Examples include:') + '<ul><li><code>*.txt</code></li>' + '<li><code>*.json,*,csv</code></li>' + '<li><code>*.json,README.md</code></li></ul>'), ) self._dlg_input.set_regex_validation(self._EXTENSIONS_LIST_REGEX) def load_values(self, data=None): """ Load file associations data. Format {'*.ext': [['Application Name', '/path/to/app/executable']]} `/path/to/app/executable` is an executable app on mac and windows and a .desktop xdg file on linux. """ self._data = data self._update_extensions() def add_association(self, value=None): """Add extension file association.""" if value is None: text, ok_pressed = '', False self._dlg_input.set_text('') if self._dlg_input.exec_(): text = self._dlg_input.text() ok_pressed = True else: match = self._regex.match(value) text, ok_pressed = value, bool(match) if ok_pressed: if text not in self._data: self._data[text] = [] self._add_association(text) self.check_data_changed() def remove_association(self): """Remove extension file association.""" if self._data: if self.current_extension: self._data.pop(self.current_extension) self._update_extensions() self._refresh() self.check_data_changed() def edit_association(self): """Edit text of current selected association.""" old_text = self.current_extension self._dlg_input.set_text(old_text) if self._dlg_input.exec_(): new_text = self._dlg_input.text() if old_text != new_text: values = self._data.pop(self.current_extension) self._data[new_text] = values self._update_extensions() self._refresh() for row in range(self.list_extensions.count()): item = self.list_extensions.item(row) if item.text() == new_text: self.list_extensions.setCurrentItem(item) break self.check_data_changed() def add_application(self): """Remove application to selected extension.""" if self.current_extension: if self._dlg_applications is None: self._dlg_applications = ApplicationsDialog(self) self._dlg_applications.set_extension(self.current_extension) if self._dlg_applications.exec_(): app_name = self._dlg_applications.application_name fpath = self._dlg_applications.application_path self._data[self.current_extension].append((app_name, fpath)) self._add_application(app_name, fpath) self.check_data_changed() def remove_application(self): """Remove application from selected extension.""" current_row = self.list_applications.currentRow() values = self._data.get(self.current_extension) if values and current_row != -1: values.pop(current_row) self.update_extensions() self.update_applications() self.check_data_changed() def set_default_application(self): """ Set the selected item on the application list as default application. """ current_row = self.list_applications.currentRow() if current_row != -1: values = self._data[self.current_extension] value = values.pop(current_row) values.insert(0, value) self._data[self.current_extension] = values self.update_extensions() self.check_data_changed() def update_extensions(self, row=None): """Update extensiosn list after additions or deletions.""" self.list_applications.clear() for extension, values in self._data.items(): if extension.strip() == self.current_extension: for (app_name, fpath) in values: self._add_application(app_name, fpath) break self.list_applications.setCurrentRow(0) self._refresh() def update_applications(self, row=None): """Update application list after additions or deletions.""" current_row = self.list_applications.currentRow() self.button_default.setEnabled(current_row != 0) def check_data_changed(self): """Check if data has changed and emit signal as needed.""" self.sig_data_changed.emit(self._data) @property def current_extension(self): """Return the current selected extension text.""" item = self.list_extensions.currentItem() if item: return item.text() @property def data(self): """Return the current file associations data.""" return self._data.copy()
class FindOptions(QWidget): """Find widget with options""" REGEX_INVALID = "background-color:rgb(255, 175, 90);" find = Signal() stop = Signal() def __init__(self, parent, search_text, search_text_regexp, search_path, exclude, exclude_idx, exclude_regexp, supported_encodings, in_python_path, more_options, case_sensitive, external_path_history): QWidget.__init__(self, parent) if search_path is None: search_path = getcwd_or_home() self.path = '' self.project_path = None self.file_path = None self.external_path = None self.external_path_history = external_path_history if not isinstance(search_text, (list, tuple)): search_text = [search_text] if not isinstance(search_path, (list, tuple)): search_path = [search_path] if not isinstance(exclude, (list, tuple)): exclude = [exclude] if not isinstance(external_path_history, (list, tuple)): external_path_history = [external_path_history] self.supported_encodings = supported_encodings # Layout 1 hlayout1 = QHBoxLayout() self.search_text = PatternComboBox(self, search_text, _("Search pattern")) self.edit_regexp = create_toolbutton(self, icon=ima.icon('advanced'), tip=_('Regular expression')) self.case_button = create_toolbutton(self, icon=get_icon("upper_lower.png"), tip=_("Case Sensitive")) self.case_button.setCheckable(True) self.case_button.setChecked(case_sensitive) self.edit_regexp.setCheckable(True) self.edit_regexp.setChecked(search_text_regexp) self.more_widgets = () self.more_options = create_toolbutton(self, toggled=self.toggle_more_options) self.more_options.setCheckable(True) self.more_options.setChecked(more_options) self.ok_button = create_toolbutton(self, text=_("Search"), icon=ima.icon('find'), triggered=lambda: self.find.emit(), tip=_("Start search"), text_beside_icon=True) self.ok_button.clicked.connect(self.update_combos) self.stop_button = create_toolbutton( self, text=_("Stop"), icon=ima.icon('editclear'), triggered=lambda: self.stop.emit(), tip=_("Stop search"), text_beside_icon=True) self.stop_button.setEnabled(False) for widget in [ self.search_text, self.edit_regexp, self.case_button, self.ok_button, self.stop_button, self.more_options ]: hlayout1.addWidget(widget) # Layout 2 hlayout2 = QHBoxLayout() self.exclude_pattern = PatternComboBox(self, exclude, _("Excluded filenames pattern")) if exclude_idx is not None and exclude_idx >= 0 \ and exclude_idx < self.exclude_pattern.count(): self.exclude_pattern.setCurrentIndex(exclude_idx) self.exclude_regexp = create_toolbutton(self, icon=ima.icon('advanced'), tip=_('Regular expression')) self.exclude_regexp.setCheckable(True) self.exclude_regexp.setChecked(exclude_regexp) exclude_label = QLabel(_("Exclude:")) exclude_label.setBuddy(self.exclude_pattern) for widget in [ exclude_label, self.exclude_pattern, self.exclude_regexp ]: hlayout2.addWidget(widget) # Layout 3 hlayout3 = QHBoxLayout() search_on_label = QLabel(_("Search in:")) self.path_selection_combo = PatternComboBox(self, exclude, _('Search directory')) self.path_selection_combo.setEditable(False) self.path_selection_contents = QListWidget(self.path_selection_combo) self.path_selection_contents.hide() self.path_selection_combo.setModel( self.path_selection_contents.model()) self.path_selection_contents.addItem(_("Current working directory")) item = self.path_selection_contents.item(0) item.setToolTip( _("Search in all files and " "directories present on the" "current Spyder path")) self.path_selection_contents.addItem(_("Project")) item = self.path_selection_contents.item(1) item.setToolTip( _("Search in all files and " "directories present on the" "current project path " "(If opened)")) item.setFlags(item.flags() & ~Qt.ItemIsEnabled) self.path_selection_contents.addItem(_("File").replace('&', '')) item = self.path_selection_contents.item(2) item.setToolTip(_("Search in current opened file")) self.path_selection_contents.addItem(_("Select other directory")) item = self.path_selection_contents.item(3) item.setToolTip(_("Search in other folder present on the file system")) self.path_selection_combo.insertSeparator(3) self.path_selection_combo.insertSeparator(5) for path in external_path_history: item = ExternalPathItem(None, path) self.path_selection_contents.addItem(item) self.path_selection_combo.currentIndexChanged.connect( self.path_selection_changed) hlayout3.addWidget(search_on_label) hlayout3.addWidget(self.path_selection_combo) self.search_text.valid.connect(lambda valid: self.find.emit()) self.exclude_pattern.valid.connect(lambda valid: self.find.emit()) vlayout = QVBoxLayout() vlayout.setContentsMargins(0, 0, 0, 0) vlayout.addLayout(hlayout1) vlayout.addLayout(hlayout2) vlayout.addLayout(hlayout3) self.more_widgets = (hlayout2, ) self.toggle_more_options(more_options) self.setLayout(vlayout) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum) @Slot(bool) def toggle_more_options(self, state): for layout in self.more_widgets: for index in range(layout.count()): if state and self.isVisible() or not state: layout.itemAt(index).widget().setVisible(state) if state: icon = ima.icon('options_less') tip = _('Hide advanced options') else: icon = ima.icon('options_more') tip = _('Show advanced options') self.more_options.setIcon(icon) self.more_options.setToolTip(tip) @Slot() def path_selection_changed(self): idx = self.path_selection_combo.currentIndex() if idx == EXTERNAL_PATH: external_path = self.select_directory() if len(external_path) > 0: item = ExternalPathItem(None, external_path) self.path_selection_contents.addItem(item) total_items = (self.path_selection_combo.count() - MAX_PATH_HISTORY) for i in range(6, total_items): self.path_selection_contents.takeItem(i) self.path_selection_combo.setCurrentIndex( self.path_selection_combo.count() - 1) else: self.path_selection_combo.setCurrentIndex(CWD) elif idx > EXTERNAL_PATH: item = self.path_selection_contents.item(idx) self.external_path = item.path def update_combos(self): self.search_text.lineEdit().returnPressed.emit() self.exclude_pattern.lineEdit().returnPressed.emit() def set_search_text(self, text): if text: self.search_text.add_text(text) self.search_text.lineEdit().selectAll() self.search_text.setFocus() def get_options(self, all=False): # Getting options self.search_text.lineEdit().setStyleSheet("") self.exclude_pattern.lineEdit().setStyleSheet("") utext = to_text_string(self.search_text.currentText()) if not utext: return try: texts = [(utext.encode('utf-8'), 'utf-8')] except UnicodeEncodeError: texts = [] for enc in self.supported_encodings: try: texts.append((utext.encode(enc), enc)) except UnicodeDecodeError: pass text_re = self.edit_regexp.isChecked() exclude = to_text_string(self.exclude_pattern.currentText()) exclude_re = self.exclude_regexp.isChecked() case_sensitive = self.case_button.isChecked() python_path = False if not case_sensitive: texts = [(text[0].lower(), text[1]) for text in texts] file_search = False selection_idx = self.path_selection_combo.currentIndex() if selection_idx == CWD: path = self.path elif selection_idx == PROJECT: path = self.project_path elif selection_idx == FILE_PATH: path = self.file_path file_search = True else: path = self.external_path # Finding text occurrences if not exclude_re: exclude = fnmatch.translate(exclude) else: try: exclude = re.compile(exclude) except Exception: exclude_edit = self.exclude_pattern.lineEdit() exclude_edit.setStyleSheet(self.REGEX_INVALID) return None if text_re: try: texts = [(re.compile(x[0]), x[1]) for x in texts] except Exception: self.search_text.lineEdit().setStyleSheet(self.REGEX_INVALID) return None if all: search_text = [ to_text_string(self.search_text.itemText(index)) for index in range(self.search_text.count()) ] exclude = [ to_text_string(self.exclude_pattern.itemText(index)) for index in range(self.exclude_pattern.count()) ] path_history = [ to_text_string(self.path_selection_contents.item(index)) for index in range(6, self.path_selection_combo.count()) ] exclude_idx = self.exclude_pattern.currentIndex() more_options = self.more_options.isChecked() return (search_text, text_re, [], exclude, exclude_idx, exclude_re, python_path, more_options, case_sensitive, path_history) else: return (path, file_search, exclude, texts, text_re, case_sensitive) @Slot() def select_directory(self): """Select directory""" self.parent().redirect_stdio.emit(False) directory = getexistingdirectory(self, _("Select directory"), self.path) if directory: directory = to_text_string(osp.abspath(to_text_string(directory))) self.parent().redirect_stdio.emit(True) return directory def set_directory(self, directory): self.path = to_text_string(osp.abspath(to_text_string(directory))) def set_project_path(self, path): self.project_path = to_text_string(osp.abspath(to_text_string(path))) item = self.path_selection_contents.item(PROJECT) item.setFlags(item.flags() | Qt.ItemIsEnabled) def disable_project_search(self): item = self.path_selection_contents.item(PROJECT) item.setFlags(item.flags() & ~Qt.ItemIsEnabled) self.project_path = None def set_file_path(self, path): self.file_path = path def keyPressEvent(self, event): """Reimplemented to handle key events""" ctrl = event.modifiers() & Qt.ControlModifier shift = event.modifiers() & Qt.ShiftModifier if event.key() in (Qt.Key_Enter, Qt.Key_Return): self.find.emit() elif event.key() == Qt.Key_F and ctrl and shift: # Toggle find widgets self.parent().toggle_visibility.emit(not self.isVisible()) else: QWidget.keyPressEvent(self, event)
class MeasurementSettings(QWidget): """ :type settings: Settings """ def __init__(self, settings: PartSettings, parent=None): super().__init__(parent) self.chosen_element: Optional[MeasurementListWidgetItem] = None self.chosen_element_area: Optional[Tuple[AreaType, float]] = None self.settings = settings self.profile_list = QListWidget(self) self.profile_description = QTextEdit(self) self.profile_description.setReadOnly(True) self.profile_options = QListWidget() self.profile_options_chosen = QListWidget() self.measurement_area_choose = QEnumComboBox(enum_class=AreaType) self.per_component = QEnumComboBox(enum_class=PerComponent) self.power_num = QDoubleSpinBox() self.power_num.setDecimals(3) self.power_num.setRange(-100, 100) self.power_num.setValue(1) self.choose_butt = QPushButton("→", self) self.discard_butt = QPushButton("←", self) self.proportion_butt = QPushButton("Ratio", self) self.proportion_butt.setToolTip("Create proportion from two parameter") self.move_up = QPushButton("↑", self) self.move_down = QPushButton("↓", self) self.remove_button = QPushButton("Remove") self.save_butt = QPushButton("Save") self.save_butt.setToolTip( "Set name for set and choose at least one parameter") self.save_butt_with_name = QPushButton( "Save with custom parameters designation") self.save_butt_with_name.setToolTip( "Set name for set and choose at least one parameter") self.reset_butt = QPushButton("Clear") self.soft_reset_butt = QPushButton("Remove user parameters") self.profile_name = QLineEdit(self) self.delete_profile_butt = QPushButton("Delete ") self.export_profiles_butt = QPushButton("Export") self.import_profiles_butt = QPushButton("Import") self.edit_profile_butt = QPushButton("Edit") self.choose_butt.setDisabled(True) self.choose_butt.clicked.connect(self.choose_option) self.discard_butt.setDisabled(True) self.discard_butt.clicked.connect(self.discard_option) self.proportion_butt.setDisabled(True) self.proportion_butt.clicked.connect(self.proportion_action) self.save_butt.setDisabled(True) self.save_butt.clicked.connect(self.save_action) self.save_butt_with_name.setDisabled(True) self.save_butt_with_name.clicked.connect(self.named_save_action) self.profile_name.textChanged.connect(self.name_changed) self.move_down.setDisabled(True) self.move_down.clicked.connect(self.move_down_fun) self.move_up.setDisabled(True) self.move_up.clicked.connect(self.move_up_fun) self.remove_button.setDisabled(True) self.remove_button.clicked.connect(self.remove_element) self.reset_butt.clicked.connect(self.reset_action) self.soft_reset_butt.clicked.connect(self.soft_reset) self.delete_profile_butt.setDisabled(True) self.delete_profile_butt.clicked.connect(self.delete_profile) self.export_profiles_butt.clicked.connect( self.export_measurement_profiles) self.import_profiles_butt.clicked.connect( self.import_measurement_profiles) self.edit_profile_butt.clicked.connect(self.edit_profile) self.profile_list.itemSelectionChanged.connect(self.profile_chosen) self.profile_options.itemSelectionChanged.connect( self.create_selection_changed) self.profile_options_chosen.itemSelectionChanged.connect( self.create_selection_chosen_changed) self.settings.measurement_profiles_changed.connect( self._refresh_profiles) layout = QVBoxLayout() layout.addWidget(QLabel("Measurement set:")) profile_layout = QHBoxLayout() profile_layout.addWidget(self.profile_list) profile_layout.addWidget(self.profile_description) profile_buttons_layout = QHBoxLayout() profile_buttons_layout.addWidget(self.delete_profile_butt) profile_buttons_layout.addWidget(self.export_profiles_butt) profile_buttons_layout.addWidget(self.import_profiles_butt) profile_buttons_layout.addWidget(self.edit_profile_butt) profile_buttons_layout.addStretch() layout.addLayout(profile_layout) layout.addLayout(profile_buttons_layout) heading_layout = QHBoxLayout() # heading_layout.addWidget(QLabel("Create profile"), 1) heading_layout.addWidget(h_line(), 6) layout.addLayout(heading_layout) name_layout = QHBoxLayout() name_layout.addWidget(QLabel("Set name:")) name_layout.addWidget(self.profile_name) name_layout.addStretch() name_layout.addWidget(QLabel("Per component:")) name_layout.addWidget(self.per_component) name_layout.addWidget(QLabel("Area:")) name_layout.addWidget(self.measurement_area_choose) name_layout.addWidget(QLabel("to power:")) name_layout.addWidget(self.power_num) layout.addLayout(name_layout) create_layout = QHBoxLayout() create_layout.addWidget(self.profile_options) butt_op_layout = QVBoxLayout() butt_op_layout.addStretch() butt_op_layout.addWidget(self.choose_butt) butt_op_layout.addWidget(self.discard_butt) butt_op_layout.addWidget(self.proportion_butt) butt_op_layout.addWidget(self.reset_butt) butt_op_layout.addStretch() create_layout.addLayout(butt_op_layout) create_layout.addWidget(self.profile_options_chosen) butt_move_layout = QVBoxLayout() butt_move_layout.addStretch() butt_move_layout.addWidget(self.move_up) butt_move_layout.addWidget(self.move_down) butt_move_layout.addWidget(self.remove_button) butt_move_layout.addStretch() create_layout.addLayout(butt_move_layout) layout.addLayout(create_layout) save_butt_layout = QHBoxLayout() save_butt_layout.addWidget(self.soft_reset_butt) save_butt_layout.addStretch() save_butt_layout.addWidget(self.save_butt) save_butt_layout.addWidget(self.save_butt_with_name) layout.addLayout(save_butt_layout) self.setLayout(layout) for profile in MEASUREMENT_DICT.values(): help_text = profile.get_description() lw = MeasurementListWidgetItem(profile.get_starting_leaf()) lw.setToolTip(help_text) self.profile_options.addItem(lw) self._refresh_profiles() def _refresh_profiles(self): item = self.profile_list.currentItem() items = list(self.settings.measurement_profiles.keys()) try: index = items.index(item.text()) except (ValueError, AttributeError): index = -1 self.profile_list.clear() self.profile_list.addItems(items) self.profile_list.setCurrentRow(index) if self.profile_list.count() == 0: self.export_profiles_butt.setDisabled(True) else: self.export_profiles_butt.setEnabled(True) def remove_element(self): elem = self.profile_options_chosen.currentItem() if elem is None: return index = self.profile_options_chosen.currentRow() self.profile_options_chosen.takeItem(index) if self.profile_options_chosen.count() == 0: self.move_down.setDisabled(True) self.move_up.setDisabled(True) self.remove_button.setDisabled(True) self.discard_butt.setDisabled(True) self.save_butt.setDisabled(True) self.save_butt_with_name.setDisabled(True) def delete_profile(self): item = self.profile_list.currentItem() del self.settings.measurement_profiles[str(item.text())] def profile_chosen(self): self.delete_profile_butt.setEnabled(True) if self.profile_list.count() == 0: self.profile_description.setText("") return item = self.profile_list.currentItem() if item is None: self.profile_description.setText("") return profile = self.settings.measurement_profiles[item.text()] self.profile_description.setText(str(profile)) def create_selection_changed(self): self.choose_butt.setEnabled(True) self.proportion_butt.setEnabled(True) def proportion_action(self): # TODO use get_parameters if self.chosen_element is None: item = self.profile_options.currentItem() self.chosen_element_area = self.get_parameters( deepcopy(item.stat), self.measurement_area_choose.currentEnum(), self.per_component.currentEnum(), self.power_num.value(), ) if self.chosen_element_area is None: return self.chosen_element = item item.setIcon(QIcon(os.path.join(icons_dir, "task-accepted.png"))) elif (self.profile_options.currentItem() == self.chosen_element and self.measurement_area_choose.currentEnum() == self.chosen_element_area.area and self.per_component.currentEnum() == self.chosen_element_area.per_component): self.chosen_element.setIcon(QIcon()) self.chosen_element = None else: item: MeasurementListWidgetItem = self.profile_options.currentItem( ) leaf = self.get_parameters( deepcopy(item.stat), self.measurement_area_choose.currentEnum(), self.per_component.currentEnum(), self.power_num.value(), ) if leaf is None: return lw = MeasurementListWidgetItem( Node(op="/", left=self.chosen_element_area, right=leaf)) lw.setToolTip("User defined") self._add_option(lw) self.chosen_element.setIcon(QIcon()) self.chosen_element = None self.chosen_element_area = None def _add_option(self, item: MeasurementListWidgetItem): for i in range(self.profile_options_chosen.count()): if item.text() == self.profile_options_chosen.item(i).text(): return self.profile_options_chosen.addItem(item) if self.good_name(): self.save_butt.setEnabled(True) self.save_butt_with_name.setEnabled(True) if self.profile_options.count() == 0: self.choose_butt.setDisabled(True) def create_selection_chosen_changed(self): # print(self.profile_options_chosen.count()) self.remove_button.setEnabled(True) if self.profile_options_chosen.count() == 0: self.move_down.setDisabled(True) self.move_up.setDisabled(True) self.remove_button.setDisabled(True) return self.discard_butt.setEnabled(True) if self.profile_options_chosen.currentRow() != 0: self.move_up.setEnabled(True) else: self.move_up.setDisabled(True) if self.profile_options_chosen.currentRow( ) != self.profile_options_chosen.count() - 1: self.move_down.setEnabled(True) else: self.move_down.setDisabled(True) def good_name(self): return str(self.profile_name.text()).strip() != "" def move_down_fun(self): row = self.profile_options_chosen.currentRow() item = self.profile_options_chosen.takeItem(row) self.profile_options_chosen.insertItem(row + 1, item) self.profile_options_chosen.setCurrentRow(row + 1) self.create_selection_chosen_changed() def move_up_fun(self): row = self.profile_options_chosen.currentRow() item = self.profile_options_chosen.takeItem(row) self.profile_options_chosen.insertItem(row - 1, item) self.profile_options_chosen.setCurrentRow(row - 1) self.create_selection_chosen_changed() def name_changed(self): if self.good_name() and self.profile_options_chosen.count() > 0: self.save_butt.setEnabled(True) self.save_butt_with_name.setEnabled(True) else: self.save_butt.setDisabled(True) self.save_butt_with_name.setDisabled(True) def form_dialog(self, arguments): return FormDialog(arguments, settings=self.settings, parent=self) def get_parameters(self, node: Union[Node, Leaf], area: AreaType, component: PerComponent, power: float): if isinstance(node, Node): return node node = node.replace_(power=power) if node.area is None: node = node.replace_(area=area) if node.per_component is None: node = node.replace_(per_component=component) with suppress(KeyError): arguments = MEASUREMENT_DICT[str(node.name)].get_fields() if len(arguments) > 0 and len(node.dict) == 0: dial = self.form_dialog(arguments) if dial.exec_(): node = node._replace(dict=dial.get_values()) else: return return node def choose_option(self): selected_item = self.profile_options.currentItem() # selected_row = self.profile_options.currentRow() if not isinstance(selected_item, MeasurementListWidgetItem): raise ValueError( f"Current item (type: {type(selected_item)} is not instance of MeasurementListWidgetItem" ) node = deepcopy(selected_item.stat) # noinspection PyTypeChecker node = self.get_parameters(node, self.measurement_area_choose.currentEnum(), self.per_component.currentEnum(), self.power_num.value()) if node is None: return lw = MeasurementListWidgetItem(node) lw.setToolTip(selected_item.toolTip()) self._add_option(lw) def discard_option(self): selected_item: MeasurementListWidgetItem = self.profile_options_chosen.currentItem( ) # selected_row = self.profile_options_chosen.currentRow() lw = MeasurementListWidgetItem(deepcopy(selected_item.stat)) lw.setToolTip(selected_item.toolTip()) self.create_selection_chosen_changed() for i in range(self.profile_options.count()): if lw.text() == self.profile_options.item(i).text(): return self.profile_options.addItem(lw) def edit_profile(self): item = self.profile_list.currentItem() if item is None: return profile = self.settings.measurement_profiles[str(item.text())] self.profile_options_chosen.clear() self.profile_name.setText(item.text()) for ch in profile.chosen_fields: self.profile_options_chosen.addItem( MeasurementListWidgetItem(ch.calculation_tree)) # self.gauss_img.setChecked(profile.use_gauss_image) self.save_butt.setEnabled(True) self.save_butt_with_name.setEnabled(True) def save_action(self): if self.profile_name.text() in self.settings.measurement_profiles: ret = QMessageBox.warning( self, "Profile exist", "Profile exist\nWould you like to overwrite it?", QMessageBox.No | QMessageBox.Yes, ) if ret == QMessageBox.No: return selected_values = [] for i in range(self.profile_options_chosen.count()): element: MeasurementListWidgetItem = self.profile_options_chosen.item( i) selected_values.append( MeasurementEntry(element.text(), element.stat)) stat_prof = MeasurementProfile(self.profile_name.text(), selected_values) self.settings.measurement_profiles[stat_prof.name] = stat_prof self.settings.dump() self.export_profiles_butt.setEnabled(True) def named_save_action(self): if self.profile_name.text() in self.settings.measurement_profiles: ret = QMessageBox.warning( self, "Profile exist", "Profile exist\nWould you like to overwrite it?", QMessageBox.No | QMessageBox.Yes, ) if ret == QMessageBox.No: return selected_values = [] for i in range(self.profile_options_chosen.count()): txt = str(self.profile_options_chosen.item(i).text()) selected_values.append((txt, str, txt)) val_dialog = MultipleInput("Set fields name", list(selected_values), parent=self) if val_dialog.exec_(): selected_values = [] for i in range(self.profile_options_chosen.count()): element: MeasurementListWidgetItem = self.profile_options_chosen.item( i) selected_values.append( MeasurementEntry(val_dialog.result[element.text()], element.stat)) stat_prof = MeasurementProfile(self.profile_name.text(), selected_values) self.settings.measurement_profiles[stat_prof.name] = stat_prof self.export_profiles_butt.setEnabled(True) def reset_action(self): self.profile_options.clear() self.profile_options_chosen.clear() self.profile_name.setText("") self.save_butt.setDisabled(True) self.save_butt_with_name.setDisabled(True) self.move_down.setDisabled(True) self.move_up.setDisabled(True) self.proportion_butt.setDisabled(True) self.choose_butt.setDisabled(True) self.discard_butt.setDisabled(True) for profile in MEASUREMENT_DICT.values(): help_text = profile.get_description() lw = MeasurementListWidgetItem(profile.get_starting_leaf()) lw.setToolTip(help_text) self.profile_options.addItem(lw) def soft_reset(self): # TODO rim should not be removed shift = 0 for i in range(self.profile_options.count()): item = self.profile_options.item(i - shift) if str(item.text()) not in MEASUREMENT_DICT: self.profile_options.takeItem(i - shift) if item == self.chosen_element: self.chosen_element = None del item shift += 1 self.create_selection_changed() def export_measurement_profiles(self): exp = ExportDialog(self.settings.measurement_profiles, StringViewer, parent=self) if not exp.exec_(): return dial = PSaveDialog( "Measurement profile (*.json)", settings=self.settings, path="io.export_directory", caption="Export settings profiles", ) dial.selectFile("measurements_profile.json") if dial.exec_(): file_path = str(dial.selectedFiles()[0]) data = { x: self.settings.measurement_profiles[x] for x in exp.get_export_list() } with open(file_path, "w", encoding="utf-8") as ff: json.dump(data, ff, cls=self.settings.json_encoder_class, indent=2) def import_measurement_profiles(self): dial = PLoadDialog( "Measurement profile (*.json)", settings=self.settings, path="io.export_directory", caption="Import settings profiles", parent=self, ) if dial.exec_(): file_path = str(dial.selectedFiles()[0]) stat, err = self.settings.load_part(file_path) if err: QMessageBox.warning( self, "Import error", "error during importing, part of data were filtered.") measurement_dict = self.settings.measurement_profiles imp = ImportDialog(stat, measurement_dict, StringViewer) if not imp.exec_(): return for original_name, final_name in imp.get_import_list(): measurement_dict[final_name] = stat[original_name] self.settings.dump()
class DownloadBibleMp3Dialog(QDialog): def __init__(self, parent): super().__init__() self.bibles = { "BBE (British accent)": ("BBE", "otseng/UniqueBible_MP3_BBE_british", "british"), "KJV (American accent)": ("KJV", "otseng/UniqueBible_MP3_KJV", "default"), "KJV (American soft music)": ("KJV", "otseng/UniqueBible_MP3_KJV_soft_music", "soft-music"), "NHEB (Indian accent)": ("NHEB", "otseng/UniqueBible_MP3_NHEB_indian", "indian"), "WEB (American accent)": ("WEB", "otseng/UniqueBible_MP3_WEB", "default"), "CUV (Chinese)": ("CUV", "otseng/UniqueBible_MP3_CUV", "default"), "HHBD (Hindi)": ("HHBD", "otseng/UniqueBible_MP3_HHBD", "default"), "RVA (Spanish)": ("RVA", "otseng/UniqueBible_MP3_RVA", "default"), "TR (Modern Greek)": ("TR", "otseng/UniqueBible_MP3_TR", "modern"), } self.parent = parent self.setWindowTitle(config.thisTranslation["gitHubBibleMp3Files"]) self.setMinimumSize(150, 450) self.selectedRendition = None self.selectedText = None self.selectedRepo = None self.selectedDirectory = None self.settingBibles = False self.thread = None self.setupUI() def setupUI(self): mainLayout = QVBoxLayout() title = QLabel(config.thisTranslation["gitHubBibleMp3Files"]) mainLayout.addWidget(title) self.versionsLayout = QVBoxLayout() self.renditionsList = QListWidget() self.renditionsList.itemClicked.connect(self.selectItem) for rendition in self.bibles.keys(): self.renditionsList.addItem(rendition) self.renditionsList.setMaximumHeight(100) self.versionsLayout.addWidget(self.renditionsList) mainLayout.addLayout(self.versionsLayout) self.downloadTable = QTableView() self.downloadTable.setEnabled(False) self.downloadTable.setFocusPolicy(Qt.StrongFocus) self.downloadTable.setEditTriggers(QAbstractItemView.NoEditTriggers) self.downloadTable.setSortingEnabled(True) self.dataViewModel = QStandardItemModel(self.downloadTable) self.downloadTable.setModel(self.dataViewModel) mainLayout.addWidget(self.downloadTable) buttonsLayout = QHBoxLayout() selectAllButton = QPushButton(config.thisTranslation["selectAll"]) selectAllButton.setFocusPolicy(Qt.StrongFocus) selectAllButton.clicked.connect(self.selectAll) buttonsLayout.addWidget(selectAllButton) selectNoneButton = QPushButton(config.thisTranslation["selectNone"]) selectNoneButton.setFocusPolicy(Qt.StrongFocus) selectNoneButton.clicked.connect(self.selectNone) buttonsLayout.addWidget(selectNoneButton) otButton = QPushButton("1-39") otButton.setFocusPolicy(Qt.StrongFocus) otButton.clicked.connect(self.selectOT) buttonsLayout.addWidget(otButton) ntButton = QPushButton("40-66") ntButton.setFocusPolicy(Qt.StrongFocus) ntButton.clicked.connect(self.selectNT) buttonsLayout.addWidget(ntButton) # buttonsLayout.addStretch() mainLayout.addLayout(buttonsLayout) self.downloadButton = QPushButton(config.thisTranslation["download"]) self.downloadButton.setFocusPolicy(Qt.StrongFocus) self.downloadButton.setAutoDefault(True) self.downloadButton.setFocus() self.downloadButton.clicked.connect(self.download) mainLayout.addWidget(self.downloadButton) self.status = QLabel("") mainLayout.addWidget(self.status) buttonLayout = QHBoxLayout() self.closeButton = QPushButton(config.thisTranslation["close"]) self.closeButton.setFocusPolicy(Qt.StrongFocus) self.closeButton.clicked.connect(self.closeDialog) buttonLayout.addWidget(self.closeButton) mainLayout.addLayout(buttonLayout) self.setLayout(mainLayout) self.renditionsList.item(0).setSelected(True) bible = self.renditionsList.item(0).text() self.selectRendition(bible) self.downloadButton.setDefault(True) QTimer.singleShot(0, self.downloadButton.setFocus) def selectItem(self, item): self.selectRendition(item.text()) def selectRendition(self, rendition): from util.GithubUtil import GithubUtil self.selectedRendition = rendition self.downloadTable.setEnabled(True) self.selectedText, self.selectedRepo, self.selectedDirectory = self.bibles[ self.selectedRendition] self.github = GithubUtil(self.selectedRepo) self.repoData = self.github.getRepoData() self.settingBibles = True self.dataViewModel.clear() rowCount = 0 for file in self.repoData.keys(): if len(str(file)) > 3: engFullBookName = file[3:] else: engFullBookName = BibleBooks().eng[str(int(file))][1] item = QStandardItem(file[:3].strip()) folder = os.path.join("audio", "bibles", self.selectedText, self.selectedDirectory, file) folderWithName = os.path.join("audio", "bibles", self.selectedText, self.selectedDirectory, file + " " + engFullBookName) if os.path.exists(folder) or os.path.exists(folderWithName): item.setCheckable(False) item.setCheckState(Qt.Unchecked) item.setEnabled(False) else: item.setCheckable(True) item.setCheckState(Qt.Checked) item.setEnabled(True) self.dataViewModel.setItem(rowCount, 0, item) item = QStandardItem(engFullBookName) self.dataViewModel.setItem(rowCount, 1, item) if os.path.exists(folder) or os.path.exists(folderWithName): item = QStandardItem("Installed") self.dataViewModel.setItem(rowCount, 2, item) else: item = QStandardItem("") self.dataViewModel.setItem(rowCount, 2, item) rowCount += 1 self.dataViewModel.setHorizontalHeaderLabels([ config.thisTranslation["menu_book"], config.thisTranslation["name"], "" ]) self.downloadTable.setColumnWidth(0, 90) self.downloadTable.setColumnWidth(1, 125) self.downloadTable.setColumnWidth(2, 125) # self.downloadTable.resizeColumnsToContents() self.settingBibles = False def selectAll(self): for index in range(self.dataViewModel.rowCount()): item = self.dataViewModel.item(index) if item.isEnabled(): item.setCheckState(Qt.Checked) def selectNone(self): for index in range(self.dataViewModel.rowCount()): item = self.dataViewModel.item(index) item.setCheckState(Qt.Unchecked) def selectOT(self): for index in range(self.dataViewModel.rowCount()): item = self.dataViewModel.item(index) bookNum = int(item.text()) if bookNum <= 39: if item.isEnabled(): item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) else: item.setCheckState(Qt.Unchecked) def selectNT(self): for index in range(self.dataViewModel.rowCount()): item = self.dataViewModel.item(index) bookNum = int(item.text()) if bookNum >= 40: if item.isEnabled(): item.setCheckState(Qt.Checked) else: item.setCheckState(Qt.Unchecked) else: item.setCheckState(Qt.Unchecked) def download(self): self.downloadButton.setEnabled(False) self.setStatus(config.thisTranslation["message_installing"]) self.closeButton.setEnabled(False) folder = os.path.join("audio", "bibles") if not os.path.exists(folder): os.mkdir(folder) folder = os.path.join("audio", "bibles", self.selectedText) if not os.path.exists(folder): os.mkdir(folder) folder = os.path.join("audio", "bibles", self.selectedText, self.selectedDirectory) if not os.path.exists(folder): os.mkdir(folder) self.thread = QThread() self.worker = DownloadFromGitHub(self.github, self.repoData, self.dataViewModel, self.selectedText, self.selectedDirectory) self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.run) self.worker.finished.connect(self.thread.quit) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.worker.deleteLater) self.worker.finished.connect(self.finishedDownloading) self.worker.progress.connect(self.setStatus) self.thread.start() def finishedDownloading(self, count): self.selectRendition(self.selectedRendition) self.setStatus("") self.downloadButton.setEnabled(True) self.closeButton.setEnabled(True) if count > 0: self.parent.displayMessage( config.thisTranslation["message_installed"]) def setStatus(self, message): self.status.setText(message) QApplication.processEvents() def closeDialog(self): if self.thread: if self.thread.isRunning(): self.thread.quit() self.close()
class EditableList(QWidget): """ Editable list with label, add, delete and edit buttons. """ sig_item_edited = Signal(object) sig_item_removed = Signal(object) sig_item_selected = Signal() def __init__(self, title=None, items_text=[], duplicates=False, normalize=True, min_items=1, confirm_remove=True, regex=None, tooltip=None): super(EditableList, self).__init__() self.duplicates = duplicates self.items_text = items_text self.normalize = normalize self.min_items = min_items self.confirm_remove = confirm_remove # Widgets self.label_title = QLabel(title) self.button_add = QPushButton(qta.icon('fa.plus'), '') self.button_remove = QPushButton(qta.icon('fa.minus'), '') self.button_edit = QPushButton(qta.icon('fa.edit'), '') self.list = QListWidget() self.delegate = EditableListDelegate(regex=regex, tooltip=tooltip) # Widget setup self.list.setItemDelegate(self.delegate) self.setMaximumHeight(self._height() * 4) # Layout label_buttons_layout = QHBoxLayout() label_buttons_layout.addWidget(self.label_title, 0) label_buttons_layout.addStretch() label_buttons_layout.addWidget(self.button_add) label_buttons_layout.addWidget(self.button_remove) label_buttons_layout.addWidget(self.button_edit) layout = QVBoxLayout() layout.addLayout(label_buttons_layout) layout.addWidget(self.list) self.setLayout(layout) # Signals self.button_add.clicked.connect(self.add) self.button_edit.clicked.connect(self.edit) self.button_remove.clicked.connect(self.remove) self.delegate.closeEditor.connect(self.check_value) self.list.currentItemChanged.connect(self.refresh) self.list.itemSelectionChanged.connect(self.sig_item_selected) # Setup self.setup() # Expose list methods self.clear = self.list.clear self.currentItem = self.list.currentItem self.setCurrentRow = self.list.setCurrentRow self.currentRow = self.list.currentRow self.item = self.list.item self.count = self.list.count def _height(self): """ Get the height for the row in the widget based on OS font metrics. """ return self.fontMetrics().height() * 2 def setup(self): """ Initial setup for populating items if any. """ # TODO: Check against regex and raise error accordingly! new_items = [] for text in self.items_text: if self.normalize: text = text.lower() new_items.append(text) self.items_text = new_items if not self.duplicates: if len(set(self.items_text)) != len(self.items_text): raise Exception('The list cannot contains duplicates.') for item in self.items_text: item = QListWidgetItem(item) item.extra_data = None item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) self.add(item) item.setSizeHint(QSize(item.sizeHint().width(), self._height())) self.refresh() def get_texts(self): """ Returns the list of texts in the list, excluding the ones under edition. """ row = self.list.currentRow() texts = [] for i in range(self.list.count()): item = self.list.item(i) if item: text = item.text().lower() if self.normalize else item.text() texts.append(text) # Check for duplicates. But the entered text already is part of the # items, so that needs to be removed to make the check if texts and row != -1: texts.pop(row) return texts def add(self, item=None): """ Return the text of all items in the list, except the current one being edited. """ if item: if item.text() in self.get_texts() and not self.duplicates: raise Exception else: self.list.addItem(item) else: item = QListWidgetItem() item.extra_data = None item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable) self.list.addItem(item) self.list.setCurrentItem(item) item.setSizeHint(QSize(item.sizeHint().width(), self._height())) self.edit() self.refresh() def remove(self): """ Remove item fron the list. """ row = self.list.currentRow() item = self.list.currentItem() if item is None: self.refresh() else: text = item.text() if self.confirm_remove: message = ("Are you sure you want to remove<br>" "<strong>{0}</strong>?".format(text)) reply = QMessageBox.question(self, 'Remove item', message, QMessageBox.Yes, QMessageBox.No) remove_item = reply == QMessageBox.Yes else: remove_item = True if row != -1 and remove_item: item = self.list.takeItem(row) self.sig_item_removed.emit(item) self.refresh() def edit(self): """ Start editing item from the list. """ self.button_remove.setDisabled(True) self.button_add.setDisabled(True) self.button_edit.setDisabled(True) item = self.current_item() if item: item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable) item._text = item.text() self.list.editItem(item) def current_item(self): """ Return the current selected item. """ item = None row = self.list.currentRow() if row != -1: item = self.list.item(row) return item def check_value(self): """ After editing an item check the value is valid and return to edit mode if it does not pass, or accept the value and add it. """ texts = self.get_texts() item = self.current_item() self._temp_item = item if item: text = item.text().lower() if self.normalize else item.text() row = self.list.currentRow() if text.strip() == '': self.list.takeItem(row) if text.strip() in texts and not self.duplicates: self.edit() else: self.sig_item_edited.emit(item) item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable) def refresh(self): """ Refresh the enabled status of the actions buttons. """ current_row = self.list.currentRow() if self.list.count() == 0: self.button_edit.setDisabled(True) self.button_remove.setDisabled(True) elif self.list.count() != 0 and current_row == -1: self.button_edit.setDisabled(True) self.button_remove.setDisabled(True) elif self.list.count() == self.min_items: self.button_add.setDisabled(False) self.button_edit.setDisabled(False) self.button_remove.setDisabled(True) elif self.list.count() != 0 and current_row != -1: self.button_add.setDisabled(False) self.button_edit.setDisabled(False) self.button_remove.setDisabled(False) for i in range(self.list.count()): item = self.list.item(i) item.setSizeHint(QSize(item.sizeHint().width(), self._height()))
class LoadDataWidget(FormBaseWidget): update_main_window_title = Signal() update_global_state = Signal() computations_complete = Signal(object) update_preview_map_range = Signal(str) signal_new_run_loaded = Signal(bool) # True/False - success/failed signal_loading_new_run = Signal() # Emitted before new run is loaded signal_data_channel_changed = Signal(bool) def __init__(self, *, gpc, gui_vars): super().__init__() # Global processing classes self.gpc = gpc # Global GUI variables (used for control of GUI state) self.gui_vars = gui_vars self.ref_main_window = self.gui_vars["ref_main_window"] self.update_global_state.connect( self.ref_main_window.update_widget_state) self.initialize() def initialize(self): v_spacing = global_gui_parameters["vertical_spacing_in_tabs"] vbox = QVBoxLayout() self._setup_wd_group() vbox.addWidget(self.group_wd) vbox.addSpacing(v_spacing) self._setup_load_group() vbox.addWidget(self.group_file) vbox.addSpacing(v_spacing) self._setup_sel_channel_group() vbox.addWidget(self.group_sel_channel) vbox.addSpacing(v_spacing) self._setup_spec_settings_group() vbox.addWidget(self.group_spec_settings) vbox.addSpacing(v_spacing) self._setup_preview_group() vbox.addWidget(self.group_preview) vbox.addStretch(1) self.setLayout(vbox) self._set_tooltips() def _setup_wd_group(self): self.group_wd = QGroupBox("Working Directory") self.pb_set_wd = PushButtonMinimumWidth("..") self.pb_set_wd.clicked.connect(self.pb_set_wd_clicked) self.le_wd = LineEditReadOnly() # Initial working directory. Set to the HOME directory for now current_dir = os.path.expanduser( self.gpc.get_current_working_directory()) self.le_wd.setText(current_dir) hbox = QHBoxLayout() hbox.addWidget(self.pb_set_wd) hbox.addWidget(self.le_wd) self.group_wd.setLayout(hbox) def _setup_load_group(self): self.group_file = QGroupBox("Load Data") self.pb_file = QPushButton("Read File ...") self.pb_file.clicked.connect(self.pb_file_clicked) self.pb_dbase = QPushButton("Load Run ...") self.pb_dbase.setEnabled( self.gui_vars["gui_state"]["databroker_available"]) self.pb_dbase.clicked.connect(self.pb_dbase_clicked) self.cb_file_all_channels = QCheckBox("All channels") self.cb_file_all_channels.setChecked(self.gpc.get_load_each_channel()) self.cb_file_all_channels.toggled.connect( self.cb_file_all_channels_toggled) self.le_file_default = "No data is loaded" self.le_file = LineEditReadOnly(self.le_file_default) self.pb_view_metadata = QPushButton("View Metadata ...") self.pb_view_metadata.setEnabled(False) self.pb_view_metadata.clicked.connect(self.pb_view_metadata_clicked) vbox = QVBoxLayout() hbox = QHBoxLayout() hbox.addWidget(self.pb_file) hbox.addWidget(self.pb_dbase) hbox.addWidget(self.cb_file_all_channels) vbox.addLayout(hbox) vbox.addWidget(self.le_file) hbox = QHBoxLayout() hbox.addStretch(1) hbox.addWidget(self.pb_view_metadata) vbox.addLayout(hbox) self.group_file.setLayout(vbox) def _setup_sel_channel_group(self): self.group_sel_channel = QGroupBox("Select Channel For Processing") self.cbox_channel = QComboBox() self.cbox_channel.currentIndexChanged.connect( self.cbox_channel_index_changed) self._set_cbox_channel_items(items=[]) hbox = QHBoxLayout() hbox.addWidget(self.cbox_channel) self.group_sel_channel.setLayout(hbox) def _setup_spec_settings_group(self): self.group_spec_settings = QGroupBox("Total Spectrum Settings") self.pb_apply_mask = QPushButton("Apply Mask ...") self.pb_apply_mask.clicked.connect(self.pb_apply_mask_clicked) hbox = QHBoxLayout() hbox.addWidget(self.pb_apply_mask) hbox.addStretch(1) self.group_spec_settings.setLayout(hbox) def _setup_preview_group(self): self.group_preview = QGroupBox("Preview") self.list_preview = QListWidget() self.list_preview.itemChanged.connect(self.list_preview_item_changed) self.list_preview.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.list_preview.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self._set_list_preview_items(items=[]) hbox = QHBoxLayout() hbox.addWidget(self.list_preview) self.group_preview.setLayout(hbox) def _set_tooltips(self): set_tooltip( self.pb_set_wd, "Select <b>Working Directory</b>. The Working Directory is " "used as <b>default</b> for loading and saving data and " "configuration files.", ) set_tooltip(self.le_wd, "Currently selected <b>Working Directory</b>") set_tooltip(self.pb_file, "Load data from a <b>file on disk</b>.") set_tooltip(self.pb_dbase, "Load data from a <b>database</b> (Databroker).") set_tooltip( self.cb_file_all_channels, "Load <b>all</b> available data channels (checked) or only the <b>sum</b> of the channels", ) set_tooltip( self.le_file, "The <b>name</b> of the loaded file or <b>ID</b> of the loaded run." ) set_tooltip(self.pb_view_metadata, "View scan <b>metadata</b> (if available)") set_tooltip( self.cbox_channel, "Select channel for processing. Typically the <b>sum</b> channel is used." ) set_tooltip( self.pb_apply_mask, "Load the mask from file and/or select spatial ROI. The mask and ROI " "are used in run <b>Preview</b> and fitting of the <b>total spectrum</b>.", ) set_tooltip( self.list_preview, "Data for the selected channels is displayed in <b>Preview</b> tab. " "The displayed <b>total spectrum</b> is computed for the selected " "ROI and using the loaded mask. If no mask or ROI are enabled, then " "total spectrum is computed over all pixels of the image.", ) def update_widget_state(self, condition=None): if condition == "tooltips": self._set_tooltips() state = self.gui_vars["gui_state"]["state_file_loaded"] self.group_sel_channel.setEnabled(state) self.group_spec_settings.setEnabled(state) self.group_preview.setEnabled(state) def _set_cbox_channel_items(self, *, items=None): """ Set items of the combo box for item selection. If the list of items is not specified, then it is loaded from the respective data structure. Parameters ---------- items: list(str) The list of items. The list may be cleared by calling `self._set_cbox_channel_items(items=[])` """ self.cbox_channel.currentIndexChanged.disconnect( self.cbox_channel_index_changed) self.cbox_channel.clear() if items is None: items = list(self.gpc.get_file_channel_list()) self.cbox_channel.addItems(items) self.cbox_channel.currentIndexChanged.connect( self.cbox_channel_index_changed) if len(items): # Select the first item (if there is at least one item) self.cbox_channel.setCurrentIndex(0) def _set_list_preview_items(self, *, items=None): """ Set items of the list for selecting channels in preview tab. If the list of items is not specified, then it is loaded from the respective data structure. Parameters ---------- items: list(str) The list of items. The list may be cleared by calling `self._set_cbox_channel_items(items=[])` """ self.list_preview.itemChanged.disconnect( self.list_preview_item_changed) self.list_preview.clear() if items is None: items = list(self.gpc.get_file_channel_list()) for s in items: wi = QListWidgetItem(s, self.list_preview) wi.setFlags(wi.flags() | Qt.ItemIsUserCheckable) wi.setFlags(wi.flags() & ~Qt.ItemIsSelectable) wi.setCheckState(Qt.Unchecked) # Adjust height so that it fits all the elements adjust_qlistwidget_height(self.list_preview, other_widgets=[self.group_preview, self]) # This will cause the preview data to be plotted (the plot is expected to be hidden, # since no channels were selected). Here we select the first channel in the list. for n, item in enumerate(items): state = Qt.Checked if self.gpc.is_dset_item_selected_for_preview( item) else Qt.Unchecked self.list_preview.item(n).setCheckState(state) self.list_preview.itemChanged.connect(self.list_preview_item_changed) def pb_set_wd_clicked(self): dir_current = self.le_wd.text() dir = QFileDialog.getExistingDirectory( self, "Select Working Directory", dir_current, QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks, ) if dir: self.gpc.set_current_working_directory(dir) self.le_wd.setText(dir) def pb_file_clicked(self): dir_current = self.gpc.get_current_working_directory() file_paths = QFileDialog.getOpenFileName(self, "Open Data File", dir_current, "HDF5 (*.h5);; All (*)") file_path = file_paths[0] if file_path: self.signal_loading_new_run.emit() def cb(file_path): result_dict = {} try: msg = self.gpc.open_data_file(file_path) status = True except Exception as ex: msg = str(ex) status = False result_dict.update({ "status": status, "msg": msg, "file_path": file_path }) return result_dict self._compute_in_background(cb, self.slot_file_clicked, file_path=file_path) @Slot(object) def slot_file_clicked(self, result): self._recover_after_compute(self.slot_file_clicked) status = result["status"] msg = result["msg"] # Message is empty if file loading failed file_path = result["file_path"] if status: file_text = f"'{self.gpc.get_loaded_file_name()}'" if self.gpc.is_scan_metadata_available(): file_text += f": ID#{self.gpc.get_metadata_scan_id()}" self.le_file.setText(file_text) self.gui_vars["gui_state"]["state_file_loaded"] = True # Invalidate fit. Fit must be rerun for new data. self.gui_vars["gui_state"]["state_model_fit_exists"] = False # Check if any datasets were loaded. self.gui_vars["gui_state"][ "state_xrf_map_exists"] = self.gpc.is_xrf_maps_available() # Disable the button for changing working directory. This is consistent # with the behavior of the old PyXRF, but will be changed in the future. self.pb_set_wd.setEnabled(False) # Enable/disable 'View Metadata' button self.pb_view_metadata.setEnabled( self.gpc.is_scan_metadata_available()) self.le_wd.setText(self.gpc.get_current_working_directory()) self.update_main_window_title.emit() self.update_global_state.emit() self._set_cbox_channel_items() self._set_list_preview_items() # Here we want to reset the range in the Total Count Map preview self.update_preview_map_range.emit("reset") self.signal_new_run_loaded.emit( True) # Data is loaded successfully if msg: # Display warning message if it was generated msgbox = QMessageBox(QMessageBox.Warning, "Warning", msg, QMessageBox.Ok, parent=self) msgbox.exec() else: self.le_file.setText(self.le_file_default) # Disable 'View Metadata' button self.pb_view_metadata.setEnabled(False) self.le_wd.setText(self.gpc.get_current_working_directory()) # Clear flags: the state now is "No data is loaded". clear_gui_state(self.gui_vars) self.update_global_state.emit() self.update_main_window_title.emit() self.update_global_state.emit() self._set_cbox_channel_items(items=[]) self._set_list_preview_items(items=[]) # Here we want to clear the range in the Total Count Map preview self.update_preview_map_range.emit("clear") self.signal_new_run_loaded.emit(False) # Failed to load data msg_str = (f"Incorrect format of input file '{file_path}': " f"PyXRF accepts only custom HDF (.h5) files." f"\n\nError message: {msg}") msgbox = QMessageBox(QMessageBox.Critical, "Error", msg_str, QMessageBox.Ok, parent=self) msgbox.exec() def pb_dbase_clicked(self): dlg = DialogSelectScan() if dlg.exec() == QDialog.Accepted: mode, id_uid = dlg.get_id_uid() self.signal_loading_new_run.emit() def cb(id_uid): result_dict = {} try: msg, file_name = self.gpc.load_run_from_db(id_uid) status = True except Exception as ex: msg, file_name = str(ex), "" status = False result_dict.update({ "status": status, "msg": msg, "id_uid": id_uid, "file_name": file_name }) return result_dict self._compute_in_background(cb, self.slot_dbase_clicked, id_uid=id_uid) @Slot(object) def slot_dbase_clicked(self, result): self._recover_after_compute(self.slot_dbase_clicked) status = result["status"] msg = result["msg"] # Message is empty if file loading failed id_uid = result["id_uid"] # file_name = result["file_name"] if status: file_text = f"'{self.gpc.get_loaded_file_name()}'" if self.gpc.is_scan_metadata_available(): file_text += f": ID#{self.gpc.get_metadata_scan_id()}" self.le_file.setText(file_text) self.gui_vars["gui_state"]["state_file_loaded"] = True # Invalidate fit. Fit must be rerun for new data. self.gui_vars["gui_state"]["state_model_fit_exists"] = False # Check if any datasets were loaded. self.gui_vars["gui_state"][ "state_xrf_map_exists"] = self.gpc.is_xrf_maps_available() # Disable the button for changing working directory. This is consistent # with the behavior of the old PyXRF, but will be changed in the future. self.pb_set_wd.setEnabled(False) # Enable/disable 'View Metadata' button self.pb_view_metadata.setEnabled( self.gpc.is_scan_metadata_available()) self.le_wd.setText(self.gpc.get_current_working_directory()) self.update_main_window_title.emit() self.update_global_state.emit() self._set_cbox_channel_items() self._set_list_preview_items() # Here we want to reset the range in the Total Count Map preview self.update_preview_map_range.emit("reset") self.signal_new_run_loaded.emit( True) # Data is loaded successfully if msg: # Display warning message if it was generated msgbox = QMessageBox(QMessageBox.Warning, "Warning", msg, QMessageBox.Ok, parent=self) msgbox.exec() else: self.le_file.setText(self.le_file_default) # Disable 'View Metadata' button self.pb_view_metadata.setEnabled(False) self.le_wd.setText(self.gpc.get_current_working_directory()) # Clear flags: the state now is "No data is loaded". clear_gui_state(self.gui_vars) self.update_global_state.emit() self.update_main_window_title.emit() self.update_global_state.emit() self._set_cbox_channel_items(items=[]) self._set_list_preview_items(items=[]) # Here we want to clear the range in the Total Count Map preview self.update_preview_map_range.emit("clear") self.signal_new_run_loaded.emit(False) # Failed to load data msg_str = f"Failed to load scan '{id_uid}'.\n\nError message: {msg}" msgbox = QMessageBox(QMessageBox.Critical, "Error", msg_str, QMessageBox.Ok, parent=self) msgbox.exec() def pb_apply_mask_clicked(self): map_size = self.gpc.get_dataset_map_size() map_size = map_size if (map_size is not None) else (0, 0) dlg = DialogLoadMask() dlg.set_image_size(n_rows=map_size[0], n_columns=map_size[1]) roi = self.gpc.get_preview_spatial_roi() dlg.set_roi( row_start=roi["row_start"], column_start=roi["col_start"], row_end=roi["row_end"], column_end=roi["col_end"], ) dlg.set_roi_active(self.gpc.is_roi_selection_active()) dlg.set_default_directory(self.gpc.get_current_working_directory()) dlg.set_mask_file_path(self.gpc.get_mask_selection_file_path()) dlg.set_mask_file_active(self.gpc.is_mask_selection_active()) if dlg.exec() == QDialog.Accepted: roi_keys = ("row_start", "col_start", "row_end", "col_end") roi_list = dlg.get_roi() roi_selected = {k: roi_list[n] for n, k in enumerate(roi_keys)} self.gpc.set_preview_spatial_roi(roi_selected) self.gpc.set_roi_selection_active(dlg.get_roi_active()) self.gpc.set_mask_selection_file_path(dlg.get_mask_file_path()) self.gpc.set_mask_selection_active(dlg.get_mask_file_active()) def cb(): try: # TODO: proper error processing is needed here (exception RuntimeError) self.gpc.apply_mask_to_datasets() success = True msg = "" except Exception as ex: success = False msg = str(ex) return {"success": success, "msg": msg} self._compute_in_background(cb, self.slot_apply_mask_clicked) @Slot(object) def slot_apply_mask_clicked(self, result): if not result["success"]: msg = f"Error occurred while applying the ROI selection:\nException: {result['msg']}" logger.error(f"{msg}") mb_error = QMessageBox(QMessageBox.Critical, "Error", f"{msg}", QMessageBox.Ok, parent=self) mb_error.exec() # Here we want to expand the range in the Total Count Map preview if needed self.update_preview_map_range.emit("update") self._recover_after_compute(self.slot_apply_mask_clicked) def pb_view_metadata_clicked(self): dlg = DialogViewMetadata() metadata_string = self.gpc.get_formatted_metadata() dlg.setText(metadata_string) dlg.exec() def cb_file_all_channels_toggled(self, state): self.gpc.set_load_each_channel(state) def cbox_channel_index_changed(self, index): def cb(index): try: self.gpc.set_data_channel(index) success, msg = True, "" except Exception as ex: success = False msg = str(ex) return {"success": success, "msg": msg} self._compute_in_background(cb, self.slot_channel_index_changed, index=index) @Slot(object) def slot_channel_index_changed(self, result): self._recover_after_compute(self.slot_channel_index_changed) if result["success"]: self.signal_data_channel_changed.emit(True) else: self.signal_data_channel_changed.emit(False) msg = result["msg"] msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() def list_preview_item_changed(self, list_item): # Find the index of the list item that was checked/unchecked ind = -1 for n in range(self.list_preview.count()): if self.list_preview.item(n) == list_item: ind = n # Get the state of the checkbox (checked -> 2, unchecked -> 0) state = list_item.checkState() # The name of the dataset dset_name = self.gpc.get_file_channel_list()[ind] def cb(): try: self.gpc.select_preview_dataset(dset_name=dset_name, is_visible=bool(state)) success, msg = True, "" except Exception as ex: success = False msg = str(ex) return {"success": success, "msg": msg} self._compute_in_background(cb, self.slot_preview_items_changed) @Slot(object) def slot_preview_items_changed(self, result): if not result["success"]: # The error shouldn't actually happen here. This is to prevent potential crashes. msg = f"Error occurred: {result['msg']}.\nData may need to be reloaded to continue processing." msgbox = QMessageBox(QMessageBox.Critical, "Error", msg, QMessageBox.Ok, parent=self) msgbox.exec() # Here we want to expand the range in the Total Count Map preview if needed self.update_preview_map_range.emit("expand") self._recover_after_compute(self.slot_preview_items_changed) def _compute_in_background(self, func, slot, *args, **kwargs): """ Run function `func` in a background thread. Send the signal `self.computations_complete` once computation is finished. Parameters ---------- func: function Reference to a function that is supposed to be executed at the background. The function return value is passed as a signal parameter once computation is complete. slot: qtpy.QtCore.Slot or None Reference to a slot. If not None, then the signal `self.computation_complete` is connected to this slot. args, kwargs arguments of the function `func`. """ signal_complete = self.computations_complete def func_to_run(func, *args, **kwargs): class LoadFile(QRunnable): def run(self): result_dict = func(*args, **kwargs) signal_complete.emit(result_dict) return LoadFile() if slot is not None: self.computations_complete.connect(slot) self.gui_vars["gui_state"]["running_computations"] = True self.update_global_state.emit() QThreadPool.globalInstance().start(func_to_run(func, *args, **kwargs)) def _recover_after_compute(self, slot): """ The function should be called after the signal `self.computations_complete` is received. The slot should be the same as the one used when calling `self.compute_in_background`. """ if slot is not None: self.computations_complete.disconnect(slot) self.gui_vars["gui_state"]["running_computations"] = False self.update_global_state.emit()
class CycleWindow(SiriusMainWindow): """Power supplies cycle window.""" def __init__(self, parent=None, checked_accs=(), adv_mode=False): """Constructor.""" super().__init__(parent) self.setObjectName('ASApp') cor = get_appropriate_color(section='AS') self.setWindowIcon(qta.icon('mdi.recycle', color=cor)) self._is_adv_mode = adv_mode # Data structs self._psnames = get_psnames(isadv=self._is_adv_mode) self._timing = Timing() self._ps2cycle = list() self._ps_ready = list() self._ps_failed = list() self._checked_accs = checked_accs # Flags self._is_preparing = '' self._prepared_init_vals = { 'timing': False, 'ps_sofbmode': False, 'ps_om_slowref': False, 'ps_current': False, 'ps_params': False, 'ps_om_cycle': False, 'trims': True } self._prepared = self._prepared_init_vals.copy() self._icon_check = qta.icon('fa5s.check') self._pixmap_check = self._icon_check.pixmap( self._icon_check.actualSize(QSize(16, 16))) self._icon_not = qta.icon('fa5s.times') self._pixmap_not = self._icon_not.pixmap( self._icon_not.actualSize(QSize(16, 16))) # Tasks self._step_2_task = { 'save_timing': SaveTiming, 'timing': PrepareTiming, 'ps_sofbmode': PreparePSSOFBMode, 'ps_om_slowref': PreparePSOpModeSlowRef, 'ps_current': PreparePSCurrentZero, 'ps_params': PreparePSParams, 'ps_om_cycle': PreparePSOpModeCycle, 'trims': CycleTrims, 'cycle': Cycle, 'restore_timing': RestoreTiming, } # Setup UI self._needs_update_setup = False self._setup_ui() self._update_setup_timer = QTimer(self) self._update_setup_timer.timeout.connect(self._update_setup) self._update_setup_timer.setInterval(250) self._update_setup_timer.start() self.setWindowTitle('PS Cycle') def _setup_ui(self): # central widget self.central_widget = QWidget() self.setCentralWidget(self.central_widget) # tree gb_tree = QGroupBox('Select power supplies:') self.pwrsupplies_tree = PVNameTree(self._psnames, ('sec', 'mag_group'), tuple(), self) self.pwrsupplies_tree.tree.setHeaderHidden(True) self.pwrsupplies_tree.tree.setColumnCount(1) glay_tree = QVBoxLayout(gb_tree) glay_tree.addWidget(self.pwrsupplies_tree) # commands lb_prep_ti = QLabel('<h4>Prepare Timing</h4>', self, alignment=Qt.AlignCenter) ti_ch = [ PVName(name).substitute(prefix=VACA_PREFIX) for name in self._timing.get_pvnames_by_psnames() ] self.ticonn_led = PyDMLedMultiConn(self, channels=ti_ch) self.save_timing_bt = QPushButton('1. Save Timing Initial State', self) self.save_timing_bt.setToolTip( 'Save timing current state as initial state.') self.save_timing_bt.clicked.connect( _part(self._run_task, 'save_timing')) self.save_timing_bt.clicked.connect(self._set_lastcomm) self.prepare_timing_bt = QPushButton('2. Prepare Timing', self) self.prepare_timing_bt.setToolTip('Prepare EVG, triggers and events') self.prepare_timing_bt.clicked.connect(_part(self._run_task, 'timing')) self.prepare_timing_bt.clicked.connect(self._set_lastcomm) self.prepare_timing_lb = QLabel(self) self.prepare_timing_lb.setPixmap(self._pixmap_not) lb_prep_ps = QLabel('<h4>Prepare PS</h4>', self, alignment=Qt.AlignCenter) self.psconn_led = PyDMLedMultiConn(self) self.set_ps_sofbmode_off_bt = QPushButton('3. Turn off PS SOFBMode', self) self.set_ps_sofbmode_off_bt.setToolTip( 'Turn off power supplies SOFBMode.') self.set_ps_sofbmode_off_bt.clicked.connect( _part(self._run_task, 'ps_sofbmode')) self.set_ps_sofbmode_off_bt.clicked.connect(self._set_lastcomm) self.set_ps_sofbmode_off_lb = QLabel(self) self.set_ps_sofbmode_off_lb.setPixmap(self._pixmap_not) self.set_ps_opmode_slowref_bt = QPushButton( '4. Set PS OpMode to SlowRef', self) self.set_ps_opmode_slowref_bt.setToolTip( 'Set power supplies OpMode to SlowRef.') self.set_ps_opmode_slowref_bt.clicked.connect( _part(self._run_task, 'ps_om_slowref')) self.set_ps_opmode_slowref_bt.clicked.connect(self._set_lastcomm) self.set_ps_opmode_slowref_lb = QLabel(self) self.set_ps_opmode_slowref_lb.setPixmap(self._pixmap_not) self.set_ps_current_zero_bt = QPushButton('5. Set PS current to zero', self) self.set_ps_current_zero_bt.setToolTip( 'Set power supplies current to zero.') self.set_ps_current_zero_bt.clicked.connect( _part(self._run_task, 'ps_current')) self.set_ps_current_zero_bt.clicked.connect(self._set_lastcomm) self.set_ps_current_zero_lb = QLabel(self) self.set_ps_current_zero_lb.setPixmap(self._pixmap_not) self.prepare_ps_params_bt = QPushButton('6. Prepare PS Parameters', self) self.prepare_ps_params_bt.setToolTip( 'Check power supplies OpMode in SlowRef, check\n' 'current is zero and configure cycle parameters.') self.prepare_ps_params_bt.clicked.connect( _part(self._run_task, 'ps_params')) self.prepare_ps_params_bt.clicked.connect(self._set_lastcomm) self.prepare_ps_params_lb = QLabel(self) self.prepare_ps_params_lb.setPixmap(self._pixmap_not) self.prepare_ps_opmode_bt = QPushButton('7. Prepare PS OpMode', self) self.prepare_ps_opmode_bt.setToolTip( 'Set power supplies OpMode to Cycle.') self.prepare_ps_opmode_bt.clicked.connect( _part(self._run_task, 'ps_om_cycle')) self.prepare_ps_opmode_bt.clicked.connect(self._set_lastcomm) self.prepare_ps_opmode_lb = QLabel(self) self.prepare_ps_opmode_lb.setPixmap(self._pixmap_not) lb_cycle = QLabel('<h4>Cycle</h4>', self, alignment=Qt.AlignCenter) self.cycle_trims_bt = QPushButton('8. Cycle Trims', self) self.cycle_trims_bt.setToolTip( 'Cycle trims:\nStep 1) CH, QS and QTrims\nStep 2) CV') self.cycle_trims_bt.clicked.connect(_part(self._run_task, 'trims')) self.cycle_trims_bt.clicked.connect(self._set_lastcomm) self.cycle_trims_bt.setVisible(False) self.cycle_trims_lb = QLabel(self) self.cycle_trims_lb.setPixmap(self._pixmap_check) self.cycle_trims_lb.setVisible(False) self.cycle_bt = QPushButton('8. Cycle', self) self.cycle_bt.setToolTip( 'Check all configurations,\nenable triggers and run cycle.') self.cycle_bt.clicked.connect(_part(self._run_task, 'cycle')) self.cycle_bt.clicked.connect(self._set_lastcomm) self.cycle_bt.setEnabled(False) lb_rest_ti = QLabel('<h4>Restore Timing</h4>', self, alignment=Qt.AlignCenter) self.restore_timing_bt = QPushButton('9. Restore Timing Initial State', self) self.restore_timing_bt.setToolTip('Restore timing initial state.') self.restore_timing_bt.clicked.connect( _part(self._run_task, 'restore_timing')) self.restore_timing_bt.clicked.connect(self._set_lastcomm) self._prepared_labels = { 'timing': self.prepare_timing_lb, 'ps_sofbmode': self.set_ps_sofbmode_off_lb, 'ps_om_slowref': self.set_ps_opmode_slowref_lb, 'ps_current': self.set_ps_current_zero_lb, 'ps_params': self.prepare_ps_params_lb, 'ps_om_cycle': self.prepare_ps_opmode_lb, 'trims': self.cycle_trims_lb } gb_commsts = QGroupBox() gb_commsts.setStyleSheet(""" QPushButton{min-height:1.5em;} QLabel{qproperty-alignment: AlignCenter;}""") lay_commsts = QGridLayout(gb_commsts) lay_commsts.addItem( QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 0, 0, 1, 2) lay_commsts.addWidget(lb_prep_ti, 1, 0) lay_commsts.addWidget(self.ticonn_led, 1, 1) lay_commsts.addWidget(self.save_timing_bt, 2, 0) lay_commsts.addWidget(self.prepare_timing_bt, 3, 0) lay_commsts.addWidget(self.prepare_timing_lb, 3, 1) lay_commsts.addItem( QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 4, 0) lay_commsts.addWidget(lb_prep_ps, 5, 0) lay_commsts.addWidget(self.psconn_led, 5, 1) lay_commsts.addWidget(self.set_ps_sofbmode_off_bt, 6, 0) lay_commsts.addWidget(self.set_ps_sofbmode_off_lb, 6, 1) lay_commsts.addWidget(self.set_ps_opmode_slowref_bt, 7, 0) lay_commsts.addWidget(self.set_ps_opmode_slowref_lb, 7, 1) lay_commsts.addWidget(self.set_ps_current_zero_bt, 8, 0) lay_commsts.addWidget(self.set_ps_current_zero_lb, 8, 1) lay_commsts.addWidget(self.prepare_ps_params_bt, 9, 0) lay_commsts.addWidget(self.prepare_ps_params_lb, 9, 1) lay_commsts.addWidget(self.prepare_ps_opmode_bt, 10, 0) lay_commsts.addWidget(self.prepare_ps_opmode_lb, 10, 1) lay_commsts.addItem( QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 11, 0) lay_commsts.addWidget(lb_cycle, 12, 0) lay_commsts.addWidget(self.cycle_trims_bt, 13, 0) lay_commsts.addWidget(self.cycle_trims_lb, 13, 1) lay_commsts.addWidget(self.cycle_bt, 14, 0) lay_commsts.addItem( QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 15, 0) lay_commsts.addWidget(lb_rest_ti, 16, 0) lay_commsts.addWidget(self.restore_timing_bt, 17, 0) lay_commsts.addItem( QSpacerItem(1, 1, QSzPlcy.Ignored, QSzPlcy.Expanding), 18, 0) lay_commsts.setColumnStretch(0, 10) lay_commsts.setColumnStretch(1, 1) lay_commsts.setVerticalSpacing(12) lay_commsts.setHorizontalSpacing(6) self.label_lastcomm = QLabel('Last Command: ', self) self.clearhist_bt = QPushButton('Clear', self) self.clearhist_bt.clicked.connect(self._clear_lastcomm) lay_lc = QHBoxLayout() lay_lc.setContentsMargins(0, 0, 0, 0) lay_lc.addWidget(self.label_lastcomm, alignment=Qt.AlignLeft) lay_lc.addWidget(self.clearhist_bt, alignment=Qt.AlignRight) lay_lc.setStretch(0, 10) lay_lc.setStretch(1, 1) self.progress_list = QListWidget(self) self.progress_list.setObjectName('progresslist') self.progress_list.setStyleSheet('#progresslist{min-width:20em;}') self.progress_list.itemDoubleClicked.connect(self._open_ps_detail) self.progress_list.setSelectionMode(QAbstractItemView.MultiSelection) self.progress_list.setToolTip( 'Select rows and press Ctrl+C to copy and Esc to deselect.') self.progress_bar = MyProgressBar(self) lay_log = QVBoxLayout() lay_log.addLayout(lay_lc) lay_log.addWidget(self.progress_list) lay_log.addWidget(self.progress_bar) # connect tree signals self.pwrsupplies_tree.tree.doubleClicked.connect(self._open_ps_detail) self.pwrsupplies_tree.tree.itemChanged.connect( self._handle_checked_items_changed) self.pwrsupplies_tree.check_requested_levels(self._checked_accs) # layout layout = QGridLayout() layout.setVerticalSpacing(10) layout.setHorizontalSpacing(10) layout.addWidget( QLabel('<h3>PS Cycle</h3>', self, alignment=Qt.AlignCenter), 0, 0, 1, 3) layout.addWidget(gb_tree, 1, 0) layout.addWidget(gb_commsts, 1, 1) layout.addLayout(lay_log, 1, 2) layout.setRowStretch(0, 1) layout.setRowStretch(1, 15) layout.setColumnStretch(0, 5) layout.setColumnStretch(1, 4) layout.setColumnStretch(2, 8) self.central_widget.setLayout(layout) # --- handle tasks --- def _run_task(self, control=''): if not self._check_connected(control): return pwrsupplies = self._get_ps_list() if not pwrsupplies: return if 'ps' in control and not self._verify_ps(pwrsupplies): return if control in self._step_2_task: task_class = self._step_2_task[control] else: raise NotImplementedError( "Task not defined for control '{}'".format(control)) self._is_preparing = control self._handle_buttons_enabled(False) self.progress_list.clear() task = task_class(parent=self, psnames=pwrsupplies, timing=self._timing, isadv=self._is_adv_mode) task.updated.connect(self._update_progress) duration = task.duration() self.progress_bar.setMinimum(0) self.progress_bar.setMaximum(duration) self.progress_bar.setValue(0) pal = self.progress_bar.palette() pal.setColor(QPalette.Highlight, self.progress_bar.default_color) self.progress_bar.setPalette(pal) self.update_bar = UpdateProgressBar(duration, self) self.update_bar.increment.connect(self.progress_bar.increment) task.start() self.update_bar.start() def _update_progress(self, text, done, warning=False, error=False): """Update automated cycle progress list and bar.""" if done: last_item = self.progress_list.item(self.progress_list.count() - 1) curr_text = last_item.text() last_item.setText(curr_text + ' done.') elif 'Remaining time' in text: last_item = self.progress_list.item(self.progress_list.count() - 1) if 'Remaining time' in last_item.text(): last_item.setText(text) else: self.progress_list.addItem(text) self.progress_list.scrollToBottom() elif 'Sent ' in text: last_item = self.progress_list.item(self.progress_list.count() - 1) if 'Sent ' in last_item.text(): last_item.setText(text) else: self.progress_list.addItem(text) self.progress_list.scrollToBottom() elif 'Successfully checked ' in text: last_item = self.progress_list.item(self.progress_list.count() - 1) if 'Successfully checked ' in last_item.text(): last_item.setText(text) else: self.progress_list.addItem(text) self.progress_list.scrollToBottom() elif 'Created connections ' in text: last_item = self.progress_list.item(self.progress_list.count() - 1) if 'Created connections ' in last_item.text(): last_item.setText(text) else: self.progress_list.addItem(text) self.progress_list.scrollToBottom() else: item = QListWidgetItem(text) if error: item.setForeground(errorcolor) self.update_bar.exit_task() pal = self.progress_bar.palette() pal.setColor(QPalette.Highlight, self.progress_bar.warning_color) self.progress_bar.setPalette(pal) if self._is_preparing in self._prepared.keys(): self._prepared[self._is_preparing] = False cycle = all(self._prepared.values()) self._handle_buttons_enabled(True, cycle=cycle) elif warning: item.setForeground(warncolor) elif 'finished' in text: self.update_bar.exit_task() self.progress_bar.setValue(self.progress_bar.maximum()) if self._is_preparing == 'cycle': self._prepared = {k: False for k in self._prepared.keys()} if not self.cycle_trims_bt.isVisible(): self._prepared['trims'] = True cycle = False else: if self._is_preparing in self._prepared.keys(): self._prepared[self._is_preparing] = True cycle = all(self._prepared.values()) self._handle_buttons_enabled(True, cycle=cycle) self._handle_stslabels_content() self.progress_list.addItem(item) self.progress_list.scrollToBottom() def _handle_buttons_enabled(self, enable, cycle=False): self.save_timing_bt.setEnabled(enable) self.prepare_timing_bt.setEnabled(enable) self.set_ps_sofbmode_off_bt.setEnabled(enable) self.set_ps_opmode_slowref_bt.setEnabled(enable) self.set_ps_current_zero_bt.setEnabled(enable) self.prepare_ps_params_bt.setEnabled(enable) self.prepare_ps_opmode_bt.setEnabled(enable) self.cycle_trims_bt.setEnabled(enable) self.cycle_bt.setEnabled(cycle) self.restore_timing_bt.setEnabled(enable) self.clearhist_bt.setEnabled(enable) self.pwrsupplies_tree.setEnabled(enable) def _handle_stslabels_content(self): for prep, value in self._prepared.items(): pixmap = self._pixmap_check if value else self._pixmap_not self._prepared_labels[prep].setPixmap(pixmap) def _set_lastcomm(self): sender_text = self.sender().text() self.label_lastcomm.setText('Last Command: ' + sender_text) def _clear_lastcomm(self): self.progress_bar.setValue(0) self.progress_list.clear() self.label_lastcomm.setText('Last Command: ') # --- handle ps selection --- def _get_ps_list(self): """Return list of power supplies to cycle.""" # Get power supplies list pwrsupplies = self.pwrsupplies_tree.checked_items() if not pwrsupplies: QMessageBox.critical(self, 'Message', 'No power supply selected!') return False sections = get_sections(pwrsupplies) if 'BO' in sections and len(sections) > 1: QMessageBox.critical(self, 'Error', 'Can not cycle Booster with other sectors!') return False create_task = CreateCyclers(parent=self, psnames=pwrsupplies) dlg = ProgressDialog('Creating cycles...', create_task, self) ret = dlg.exec_() if ret == dlg.Rejected: return False return pwrsupplies def _handle_checked_items_changed(self, item): psname = PVName(item.data(0, Qt.DisplayRole)) if not _re.match('.*-.*:.*-.*', psname): return if not self._is_adv_mode and psname.sec == 'SI' and \ not psname.dev.startswith('FC'): psname2check = Filter.process_filters(self._psnames, filters={ 'sec': 'SI', 'dev': '(?!FC)' }) psname2check.remove(psname) state2set = item.checkState(0) self.pwrsupplies_tree.tree.blockSignals(True) for psn in psname2check: item2check = self.pwrsupplies_tree._item_map[psn] if item2check.checkState(0) != state2set: item2check.setData(0, Qt.CheckStateRole, state2set) self.pwrsupplies_tree.tree.blockSignals(False) else: if (psname.sec in ['BO', 'SI'] and psname.dev in ['B', 'B1B2']): psname2check = PSSearch.get_psnames({ 'sec': psname.sec, 'dev': 'B.*' }) psname2check.remove(psname) item2check = self.pwrsupplies_tree._item_map[psname2check[0]] state2set = item.checkState(0) state2change = item2check.checkState(0) if state2change != state2set: self.pwrsupplies_tree.tree.blockSignals(True) item2check.setData(0, Qt.CheckStateRole, state2set) self.pwrsupplies_tree.tree.blockSignals(False) self._prepared.update(self._prepared_init_vals) self._needs_update_setup = True def _update_setup(self): if not self._needs_update_setup: return self._needs_update_setup = False # update leds psnames = self.pwrsupplies_tree.checked_items() ti_ch = [ PVName(name).substitute(prefix=VACA_PREFIX) for name in self._timing.get_pvnames_by_psnames(psnames) ] self.ticonn_led.set_channels(ti_ch) ps_ch = list() for name in psnames: ps_ch.append( PVName(name).substitute(prefix=VACA_PREFIX, propty='PwrState-Sts')) self.psconn_led.set_channels(ps_ch) # update buttons and self._prepared dict if not in advanced mode if not self._is_adv_mode: has_si = False for psn in PSSearch.get_psnames({'sec': 'SI', 'dis': 'PS'}): if psn not in self.pwrsupplies_tree._item_map: continue item = self.pwrsupplies_tree._item_map[psn] has_si |= item.checkState(0) != 0 if not has_si: self.cycle_bt.setText('8. Cycle') self.restore_timing_bt.setText( '9. Restore Timing Initial State') self.cycle_trims_bt.setVisible(False) self.cycle_trims_lb.setVisible(False) self._prepared['trims'] = True else: self.cycle_bt.setText('9. Cycle') self.restore_timing_bt.setText( '10. Restore Timing Initial State') self.cycle_trims_bt.setVisible(True) self.cycle_trims_lb.setVisible(True) self._prepared['trims'] = False self._handle_stslabels_content() self._handle_buttons_enabled(True) # --- auxiliary checks --- def _check_connected(self, control): if control in ['trims', 'cycle']: leds = [self.ticonn_led, self.psconn_led] elif 'timing' in control: leds = [ self.ticonn_led, ] else: leds = [ self.psconn_led, ] for led in leds: pvs_disconnected = set() for ch, v in led.channels2conn.items(): if not v: pvs_disconnected.add(ch) if pvs_disconnected: sttr = '' for item in pvs_disconnected: sttr += item + '\n' QMessageBox.information( self, 'Message', 'The following PVs are not connected:\n' + sttr) return False return True def _verify_ps(self, pwrsupplies): self._ps_failed = set() task = VerifyPS(parent=self, psnames=pwrsupplies) task.itemDone.connect(self._get_ps_not_ready_2_cycle) dlg = ProgressDialog('Verifying power supplies initial state...', task, self) ret = dlg.exec_() if ret == dlg.Rejected: self._handle_buttons_enabled(True) return False if self._ps_failed: text = 'Verify power state and interlocks' \ ' of the following power supplies' dlg = PSStatusDialog(self._ps_failed, text, self) dlg.exec_() self._handle_buttons_enabled(True) return False return True def _get_ps_not_ready_2_cycle(self, psname, status): if not status: self._ps_failed.add(psname) def _open_ps_detail(self, item): if self.sender() == self.progress_list: text_split = item.data(Qt.DisplayRole).split(' ') psname = '' for text in text_split: if _re.match('.*-.*:.*-.*', text): psname = text if not psname: return else: psname = item.data() if not _re.match('.*-.*:.*-.*', psname): if item.model().rowCount(item) == 1: psname = item.child(0, 0).data() else: return run_newprocess(['sirius-hla-as-ps-detail.py', psname]) # --- events --- def keyPressEvent(self, evt): """Implement keyPressEvent.""" if evt.matches(QKeySequence.Copy) and self.progress_list.underMouse(): items = self.progress_list.selectedItems() items = '\n'.join([i.text() for i in items]) QApplication.clipboard().setText(items) if evt.key() == Qt.Key_Escape and self.progress_list.underMouse(): items = self.progress_list.clearSelection() super().keyPressEvent(evt) def closeEvent(self, ev): self._update_setup_timer.stop() super().closeEvent(ev)
class ExportDialog(QDialog): def __init__(self, export_dict, viewer): super(ExportDialog, self).__init__() self.setWindowTitle("Export") self.export_dict = export_dict self.viewer = viewer() self.list_view = QListWidget() self.check_state = np.zeros(len(export_dict), dtype=np.bool) self.check_state[...] = True for el in sorted(export_dict.keys()): item = QListWidgetItem(el) # noinspection PyTypeChecker item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Checked) self.list_view.addItem(item) self.checked_num = len(export_dict) self.export_btn = QPushButton("Export") self.cancel_btn = QPushButton("Cancel") self.check_btn = QPushButton("Check all") self.uncheck_btn = QPushButton("Uncheck all") self.cancel_btn.clicked.connect(self.close) self.export_btn.clicked.connect(self.accept) self.check_btn.clicked.connect(self.check_all) self.uncheck_btn.clicked.connect(self.uncheck_all) self.list_view.itemSelectionChanged.connect(self.preview) self.list_view.itemChanged.connect(self.checked_change) layout = QVBoxLayout() info_layout = QHBoxLayout() info_layout.addWidget(self.list_view) info_layout.addWidget(self.viewer) layout.addLayout(info_layout) btn_layout = QHBoxLayout() btn_layout.addWidget(self.check_btn) btn_layout.addWidget(self.uncheck_btn) btn_layout.addStretch() btn_layout.addWidget(self.export_btn) btn_layout.addWidget(self.cancel_btn) layout.addLayout(btn_layout) self.setLayout(layout) def checked_change(self, item): if item.checkState() == Qt.Unchecked: self.checked_num -= 1 else: self.checked_num += 1 if self.checked_num == 0: self.export_btn.setDisabled(True) else: self.export_btn.setEnabled(True) def get_checked(self): res = [] for i in range(self.list_view.count()): it = self.list_view.item(i) if it.checkState() == Qt.Checked: res.append(str(it.text())) return res def preview(self): name = str(self.list_view.currentItem().text()) self.viewer.preview_object(self.export_dict[name]) def check_change(self): item = self.list_view.currentItem() # type: QListWidgetItem index = self.list_view.currentRow() checked = item.checkState() == Qt.Checked self.check_state[index] = checked self.export_btn.setEnabled(np.any(self.check_state)) def uncheck_all(self): for index in range(self.list_view.count()): item = self.list_view.item(index) item.setCheckState(Qt.Unchecked) self.check_state[...] = False self.export_btn.setDisabled(True) self.checked_num = 0 def check_all(self): for index in range(self.list_view.count()): item = self.list_view.item(index) item.setCheckState(Qt.Checked) self.checked_num = len(self.export_dict) self.check_state[...] = True self.export_btn.setDisabled(False) def get_export_list(self): res = [] for num in range(self.list_view.count()): item = self.list_view.item(num) if item.checkState() == Qt.Checked: res.append(str(item.text())) return res
class Devices(QFrame): def __init__(self, *args, **kwargs): super(Devices, self).__init__(*args, **kwargs) self.setFrameStyle(QFrame.Panel | QFrame.Raised) self.contentLayout = QGridLayout() self.devices = [] # Current Action Status self.status = {} self.devicePrefixFilterLabel = QLabel( "Device filter (Ion Pump not the channel!)") self.devicePrefixFilterInp = QLineEdit() self.devicePrefixFilterInp.setMaximumWidth(100) self.updateDeviceListButton = QPushButton("Apply Filter") self.updateDeviceListButton.clicked.connect(self.updateDeviceList) self.updateDeviceListButton.setToolTip( "Filter the device prefix list.") self.contentLayout.addWidget(self.devicePrefixFilterLabel, 0, 0, 1, 2) self.contentLayout.addWidget(self.devicePrefixFilterInp, 1, 0, 1, 1) self.contentLayout.addWidget(self.updateDeviceListButton, 1, 1, 1, 1) self.deviceList = QListWidget() self.contentLayout.addWidget(self.deviceList, 2, 0, 2, 2) self.deviceStatus = QTableWidget() self.deviceStatus.setColumnCount(2) self.deviceStatus.horizontalHeader().setSectionResizeMode( QHeaderView.Stretch) self.deviceStatus.setHorizontalHeaderLabels(["Device", "Status"]) self.deviceStatusLabel = QLabel("Status") self.contentLayout.addWidget(self.deviceStatusLabel, 0, 2, 1, 2) self.contentLayout.addWidget(self.deviceStatus, 1, 2, 4, 2) self.contentLayout.setRowStretch(2, 2) self.setLayout(self.contentLayout) self.deviceList.itemChanged.connect(self.highlightChecked) self.reloadData() def updateStatus(self, param): self.status[param["dev"]] = "{}".format(param["status"]) idx = 0 self.deviceStatus.setRowCount(len(self.status)) for k, v in self.status.items(): self.deviceStatus.setItem(idx, 0, QTableWidgetItem(k)) self.deviceStatus.setItem(idx, 1, QTableWidgetItem(v)) idx += 1 def getSelectedDevices(self): checked_devices = [] count = 0 while count < self.deviceList.count(): item = self.deviceList.item(count) if item.checkState() == Qt.Checked: checked_devices.append(item.text()) count += 1 _devices = [] for prefix in checked_devices: for device in self.devices: if device["prefix"] == prefix: _devices.append(device) break return _devices def highlightChecked(self, item): if item.checkState() == Qt.Checked: item.setBackground(QColor("#ffffb2")) else: item.setBackground(QColor("#ffffff")) def updateDeviceList(self): self.deviceList.clear() _filter = self.devicePrefixFilterInp.text() devs = [] for d in self.devices: if _filter == "" or _filter in d["prefix"]: devs.append(d["prefix"]) self.deviceList.addItems(devs) count = 0 while count < self.deviceList.count(): item = self.deviceList.item(count) item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) count += 1 def reloadData(self): data = getAgilent() self.devices = [d for d in getDevices(data)] self.updateDeviceList()
class FileSwitcher(QDialog): """A Sublime-like file switcher.""" sig_goto_file = Signal(int, object) # Constants that define the mode in which the list widget is working # FILE_MODE is for a list of files, SYMBOL_MODE if for a list of symbols # in a given file when using the '@' symbol. FILE_MODE, SYMBOL_MODE = [1, 2] MAX_WIDTH = 600 def __init__(self, parent, plugin, tabs, data, icon): QDialog.__init__(self, parent) # Variables self.plugins_tabs = [] self.plugins_data = [] self.plugins_instances = [] self.add_plugin(plugin, tabs, data, icon) self.plugin = None # Last plugin with focus self.mode = self.FILE_MODE # By default start in this mode self.initial_cursors = None # {fullpath: QCursor} self.initial_path = None # Fullpath of initial active editor self.initial_widget = None # Initial active editor self.line_number = None # Selected line number in filer self.is_visible = False # Is the switcher visible? help_text = _("Press <b>Enter</b> to switch files or <b>Esc</b> to " "cancel.<br><br>Type to filter filenames.<br><br>" "Use <b>:number</b> to go to a line, e.g. " "<b><code>main:42</code></b><br>" "Use <b>@symbol_text</b> to go to a symbol, e.g. " "<b><code>@init</code></b>" "<br><br> Press <b>Ctrl+W</b> to close current tab.<br>") # Either allow searching for a line number or a symbol but not both regex = QRegExp("([A-Za-z0-9_]{0,100}@[A-Za-z0-9_]{0,100})|" + "([A-Za-z0-9_]{0,100}:{0,1}[0-9]{0,100})") # Widgets self.edit = FilesFilterLine(self) self.help = HelperToolButton() self.list = QListWidget(self) self.filter = KeyPressFilter() regex_validator = QRegExpValidator(regex, self.edit) # Widgets setup self.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint) self.setWindowOpacity(0.95) self.edit.installEventFilter(self.filter) self.edit.setValidator(regex_validator) self.help.setToolTip(help_text) self.list.setItemDelegate(HTMLDelegate(self)) # Layout edit_layout = QHBoxLayout() edit_layout.addWidget(self.edit) edit_layout.addWidget(self.help) layout = QVBoxLayout() layout.addLayout(edit_layout) layout.addWidget(self.list) self.setLayout(layout) # Signals self.rejected.connect(self.restore_initial_state) self.filter.sig_up_key_pressed.connect(self.previous_row) self.filter.sig_down_key_pressed.connect(self.next_row) self.edit.returnPressed.connect(self.accept) self.edit.textChanged.connect(self.setup) self.list.itemSelectionChanged.connect(self.item_selection_changed) self.list.clicked.connect(self.edit.setFocus) # --- Properties @property def widgets(self): widgets = [] for tabs, plugin in self.plugins_tabs: widgets += [(tabs.widget(index), plugin) for index in range(tabs.count())] return widgets @property def line_count(self): line_count = [] for widget in self.widgets: try: current_line_count = widget[0].get_line_count() except AttributeError: current_line_count = 0 line_count.append(current_line_count) return line_count @property def save_status(self): save_status = [] for da, icon in self.plugins_data: save_status += [getattr(td, 'newly_created', False) for td in da] return save_status @property def paths(self): paths = [] for da, icon in self.plugins_data: paths += [getattr(td, 'filename', None) for td in da] return paths @property def filenames(self): filenames = [] for da, icon in self.plugins_data: filenames += [os.path.basename(getattr(td, 'filename', None)) for td in da] return filenames @property def icons(self): icons = [] for da, icon in self.plugins_data: icons += [icon for td in da] return icons @property def current_path(self): return self.paths_by_widget[self.get_widget()] @property def paths_by_widget(self): widgets = [w[0] for w in self.widgets] return dict(zip(widgets, self.paths)) @property def widgets_by_path(self): widgets = [w[0] for w in self.widgets] return dict(zip(self.paths, widgets)) @property def filter_text(self): """Get the normalized (lowecase) content of the filter text.""" return to_text_string(self.edit.text()).lower() def set_search_text(self, _str): self.edit.setText(_str) def save_initial_state(self): """Save initial cursors and initial active widget.""" paths = self.paths self.initial_widget = self.get_widget() self.initial_cursors = {} for i, editor in enumerate(self.widgets): if editor is self.initial_widget: self.initial_path = paths[i] # This try is needed to make the fileswitcher work with # plugins that does not have a textCursor. try: self.initial_cursors[paths[i]] = editor.textCursor() except AttributeError: pass def accept(self): self.is_visible = False QDialog.accept(self) self.list.clear() def restore_initial_state(self): """Restores initial cursors and initial active editor.""" self.list.clear() self.is_visible = False widgets = self.widgets_by_path if not self.edit.clicked_outside: for path in self.initial_cursors: cursor = self.initial_cursors[path] if path in widgets: self.set_editor_cursor(widgets[path], cursor) if self.initial_widget in self.paths_by_widget: index = self.paths.index(self.initial_path) self.sig_goto_file.emit(index) def set_dialog_position(self): """Positions the file switcher dialog.""" parent = self.parent() geo = parent.geometry() width = self.list.width() # This has been set in setup left = parent.geometry().width()/2 - width/2 # Note: the +1 pixel on the top makes it look better if isinstance(parent, QMainWindow): top = (parent.toolbars_menu.geometry().height() + parent.menuBar().geometry().height() + 1) else: top = self.plugins_tabs[0][0].tabBar().geometry().height() + 1 while parent: geo = parent.geometry() top += geo.top() left += geo.left() parent = parent.parent() self.move(left, top) def get_item_size(self, content): """ Get the max size (width and height) for the elements of a list of strings as a QLabel. """ strings = [] if content: for rich_text in content: label = QLabel(rich_text) label.setTextFormat(Qt.PlainText) strings.append(label.text()) fm = label.fontMetrics() return (max([fm.width(s) * 1.3 for s in strings]), fm.height()) def fix_size(self, content): """ Adjusts the width and height of the file switcher based on the relative size of the parent and content. """ # Update size of dialog based on relative size of the parent if content: width, height = self.get_item_size(content) # Width parent = self.parent() relative_width = parent.geometry().width() * 0.65 if relative_width > self.MAX_WIDTH: relative_width = self.MAX_WIDTH self.list.setMinimumWidth(relative_width) # Height if len(content) < 8: max_entries = len(content) else: max_entries = 8 max_height = height * max_entries * 2.5 self.list.setMinimumHeight(max_height) # Resize self.list.resize(relative_width, self.list.height()) # --- Helper methods: List widget def count(self): """Gets the item count in the list widget.""" return self.list.count() def current_row(self): """Returns the current selected row in the list widget.""" return self.list.currentRow() def set_current_row(self, row): """Sets the current selected row in the list widget.""" return self.list.setCurrentRow(row) def select_row(self, steps): """Select row in list widget based on a number of steps with direction. Steps can be positive (next rows) or negative (previous rows). """ row = self.current_row() + steps if 0 <= row < self.count(): self.set_current_row(row) def previous_row(self): """Select previous row in list widget.""" if self.mode == self.SYMBOL_MODE: self.select_row(-1) return prev_row = self.current_row() - 1 if prev_row >= 0: title = self.list.item(prev_row).text() else: title = '' if prev_row == 0 and '</b></big><br>' in title: self.list.scrollToTop() elif '</b></big><br>' in title: # Select the next previous row, the one following is a title self.select_row(-2) else: self.select_row(-1) def next_row(self): """Select next row in list widget.""" if self.mode == self.SYMBOL_MODE: self.select_row(+1) return next_row = self.current_row() + 1 if next_row < self.count(): if '</b></big><br>' in self.list.item(next_row).text(): # Select the next next row, the one following is a title self.select_row(+2) else: self.select_row(+1) def get_stack_index(self, stack_index, plugin_index): """Get the real index of the selected item.""" other_plugins_count = sum([other_tabs[0].count() \ for other_tabs in \ self.plugins_tabs[:plugin_index]]) real_index = stack_index - other_plugins_count return real_index # --- Helper methods: Widget def get_widget(self, index=None, path=None, tabs=None): """Get widget by index. If no tabs and index specified the current active widget is returned. """ if index and tabs: return tabs.widget(index) elif path and tabs: return tabs.widget(index) elif self.plugin: index = self.plugins_instances.index(self.plugin) return self.plugins_tabs[index][0].currentWidget() else: return self.plugins_tabs[0][0].currentWidget() def set_editor_cursor(self, editor, cursor): """Set the cursor of an editor.""" pos = cursor.position() anchor = cursor.anchor() new_cursor = QTextCursor() if pos == anchor: new_cursor.movePosition(pos) else: new_cursor.movePosition(anchor) new_cursor.movePosition(pos, QTextCursor.KeepAnchor) editor.setTextCursor(cursor) def goto_line(self, line_number): """Go to specified line number in current active editor.""" if line_number: line_number = int(line_number) editor = self.get_widget() try: editor.go_to_line(min(line_number, editor.get_line_count())) except AttributeError: pass # --- Helper methods: Outline explorer def get_symbol_list(self): """Get the list of symbols present in the file.""" try: oedata = self.get_widget().get_outlineexplorer_data() except AttributeError: oedata = {} return oedata # --- Handlers def item_selection_changed(self): """List widget item selection change handler.""" row = self.current_row() if self.count() and row >= 0: if '</b></big><br>' in self.list.currentItem().text() and row == 0: self.next_row() if self.mode == self.FILE_MODE: try: stack_index = self.paths.index(self.filtered_path[row]) self.plugin = self.widgets[stack_index][1] plugin_index = self.plugins_instances.index(self.plugin) # Count the real index in the tabWidget of the # current plugin real_index = self.get_stack_index(stack_index, plugin_index) self.sig_goto_file.emit(real_index, self.plugin.get_current_tab_manager()) self.goto_line(self.line_number) try: self.plugin.switch_to_plugin() self.raise_() except AttributeError: # The widget using the fileswitcher is not a plugin pass self.edit.setFocus() except ValueError: pass else: line_number = self.filtered_symbol_lines[row] self.goto_line(line_number) def setup_file_list(self, filter_text, current_path): """Setup list widget content for file list display.""" short_paths = shorten_paths(self.paths, self.save_status) paths = self.paths icons = self.icons results = [] trying_for_line_number = ':' in filter_text # Get optional line number if trying_for_line_number: filter_text, line_number = filter_text.split(':') # Get all the available filenames scores = get_search_scores('', self.filenames, template="<b>{0}</b>") else: line_number = None # Get all available filenames and get the scores for # "fuzzy" matching scores = get_search_scores(filter_text, self.filenames, template="<b>{0}</b>") # Get max width to determine if shortpaths should be used max_width = self.get_item_size(paths)[0] self.fix_size(paths) # Build the text that will appear on the list widget for index, score in enumerate(scores): text, rich_text, score_value = score if score_value != -1: text_item = '<big>' + rich_text.replace('&', '') + '</big>' if trying_for_line_number: text_item += " [{0:} {1:}]".format(self.line_count[index], _("lines")) if max_width > self.list.width(): text_item += u"<br><i>{0:}</i>".format(short_paths[index]) else: text_item += u"<br><i>{0:}</i>".format(paths[index]) if (trying_for_line_number and self.line_count[index] != 0 or not trying_for_line_number): results.append((score_value, index, text_item)) # Sort the obtained scores and populate the list widget self.filtered_path = [] plugin = None for result in sorted(results): index = result[1] path = paths[index] icon = icons[index] text = '' try: title = self.widgets[index][1].get_plugin_title().split(' - ') if plugin != title[0]: plugin = title[0] text += '<br><big><b>' + plugin + '</b></big><br>' item = QListWidgetItem(text) item.setToolTip(path) item.setSizeHint(QSize(0, 25)) item.setFlags(Qt.ItemIsEditable) self.list.addItem(item) self.filtered_path.append(path) except: # The widget using the fileswitcher is not a plugin pass text = '' text += result[-1] item = QListWidgetItem(icon, text) item.setToolTip(path) item.setSizeHint(QSize(0, 25)) self.list.addItem(item) self.filtered_path.append(path) # To adjust the delegate layout for KDE themes self.list.files_list = True # Move selected item in list accordingly and update list size if current_path in self.filtered_path: self.set_current_row(self.filtered_path.index(current_path)) elif self.filtered_path: self.set_current_row(0) # If a line number is searched look for it self.line_number = line_number self.goto_line(line_number) def setup_symbol_list(self, filter_text, current_path): """Setup list widget content for symbol list display.""" # Get optional symbol name filter_text, symbol_text = filter_text.split('@') # Fetch the Outline explorer data, get the icons and values oedata = self.get_symbol_list() icons = get_python_symbol_icons(oedata) # The list of paths here is needed in order to have the same # point of measurement for the list widget size as in the file list # See issue 4648 paths = self.paths # Update list size self.fix_size(paths) symbol_list = process_python_symbol_data(oedata) line_fold_token = [(item[0], item[2], item[3]) for item in symbol_list] choices = [item[1] for item in symbol_list] scores = get_search_scores(symbol_text, choices, template="<b>{0}</b>") # Build the text that will appear on the list widget results = [] lines = [] self.filtered_symbol_lines = [] for index, score in enumerate(scores): text, rich_text, score_value = score line, fold_level, token = line_fold_token[index] lines.append(text) if score_value != -1: results.append((score_value, line, text, rich_text, fold_level, icons[index], token)) template = '{0}{1}' for (score, line, text, rich_text, fold_level, icon, token) in sorted(results): fold_space = ' '*(fold_level) line_number = line + 1 self.filtered_symbol_lines.append(line_number) textline = template.format(fold_space, rich_text) item = QListWidgetItem(icon, textline) item.setSizeHint(QSize(0, 16)) self.list.addItem(item) # To adjust the delegate layout for KDE themes self.list.files_list = False # Move selected item in list accordingly # NOTE: Doing this is causing two problems: # 1. It makes the cursor to auto-jump to the last selected # symbol after opening or closing a different file # 2. It moves the cursor to the first symbol by default, # which is very distracting. # That's why this line is commented! # self.set_current_row(0) def setup(self): """Setup list widget content.""" if len(self.plugins_tabs) == 0: self.close() return self.list.clear() current_path = self.current_path filter_text = self.filter_text # Get optional line or symbol to define mode and method handler trying_for_symbol = ('@' in self.filter_text) if trying_for_symbol: self.mode = self.SYMBOL_MODE self.setup_symbol_list(filter_text, current_path) else: self.mode = self.FILE_MODE self.setup_file_list(filter_text, current_path) # Set position according to size self.set_dialog_position() def add_plugin(self, plugin, tabs, data, icon): """Add a plugin to display its files.""" self.plugins_tabs.append((tabs, plugin)) self.plugins_data.append((data, icon)) self.plugins_instances.append(plugin)
class PMGListCtrl(BaseExtendedWidget): def __init__(self, layout_dir: str, title: str, initial_value: List[List[str]], new_id_func: Callable = None): super().__init__(layout_dir) self.choices = [] self.text_list = [] lab_title = QLabel(text=title) layout = QHBoxLayout() self.central_layout.addWidget(lab_title) self.on_check_callback = None self.list_widget = QListWidget() self.list_widget.mouseDoubleClickEvent = self.on_listwidget_double_cicked self.set_value(initial_value) layout_tools = QVBoxLayout() self.button_add_item = QPushButton('+') self.button_delete_item = QPushButton('-') self.button_delete_item.clicked.connect(self.delete_row) self.button_add_item.clicked.connect(self.add_row) self.button_add_item.setMaximumWidth(20) self.button_delete_item.setMaximumWidth(20) layout_tools.addWidget(self.button_add_item) layout_tools.addWidget(self.button_delete_item) layout.addLayout(layout_tools) layout.addWidget(self.list_widget) self.central_layout.addLayout(layout) self.data = initial_value self.new_id_func = new_id_func self.text_edit = QLineEdit(parent=self.list_widget) self.text_edit.setWindowFlags(self.text_edit.windowFlags() | Qt.Dialog | Qt.FramelessWindowHint) self.text_edit.hide() self.completer = QCompleter() self.text_edit.setCompleter(self.completer) self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion) def set_completions(self, completions: List[str]): """ 设置补全内容 Args: completions: Returns: """ self.completer.setModel(QStringListModel(completions)) def new_id(self): if callable(self.new_id_func): return self.new_id_func() else: return None def add_row(self): self.data = self.get_value() self.data[0].append(self.new_id()) self.data[1].append('Unnamed') self.list_widget.addItem(QListWidgetItem('Unnamed')) def delete_row(self): index = self.list_widget.currentIndex().row() self.data[0].pop(index) self.data[1].pop(index) self.list_widget.takeItem(index) def on_listwidget_double_cicked(self, evt: QMouseEvent): print('edit', evt) pos = evt.globalPos() current_item: QListWidgetItem = self.list_widget.currentItem() def set_value(): current_item.setText(self.text_edit.text()) self.text_edit.hide() self.text_edit.returnPressed.disconnect(set_value) item: QListWidgetItem = self.list_widget.currentItem() self.text_edit.setGeometry(pos.x(), pos.y(), 200, 20) self.text_edit.returnPressed.connect(set_value) self.text_edit.show() # self.list_widget.editItem(item) def get_value(self): text = [] for i in range(self.list_widget.count()): text.append(self.list_widget.item(i).text()) self.data[1] = text assert len(self.data[1]) == len(self.data[0]), repr(self.data) return self.data def set_value(self, data: List[List[str]]): self.list_widget.clear() self.list_widget.addItems(data[1]) self.data = data for index in range(self.list_widget.count()): item: QListWidgetItem = self.list_widget.item(index)
def list_texts(widget: QListWidget) -> Iterator[str]: """Generator to get the text from list widget.""" for row in range(widget.count()): yield widget.item(row).text()
class GroupsModify(PyDialog): """ +--------------------------+ | Groups : Modify | +--------------------------+ | | | Name xxx Default | | Coords xxx Default | | Elements xxx Default | | Color xxx Default | | Add xxx Add | | Remove xxx Remove | | | | Set OK Cancel | +--------------------------+ """ def __init__(self, data, win_parent=None, group_active='main'): PyDialog.__init__(self, data, win_parent) self.set_font_size(data['font_size']) self._updated_groups = False #self.out_data = data #print(data) keys = [] self.keys = [ group.name for key, group in sorted(iteritems(data)) if isinstance(key, int) ] self.active_key = self.keys.index(group_active) group_obj = data[self.active_key] name = group_obj.name self.imain = 0 self.nrows = len(self.keys) self._default_name = group_obj.name self._default_elements = group_obj.element_str self.elements_pound = group_obj.elements_pound self.table = QListWidget(parent=None) self.table.clear() self.table.addItems(self.keys) self.setWindowTitle('Groups: Modify') self.create_widgets() self.create_layout() self.set_connections() self.on_set_as_main() def create_widgets(self): """creates the menu objects""" # Name self.name = QLabel("Name:") self.name_set = QPushButton("Set") self.name_edit = QLineEdit(str(self._default_name).strip()) self.name_button = QPushButton("Default") # elements self.elements = QLabel("Element IDs:") self.elements_edit = QLineEdit(str(self._default_elements).strip()) self.elements_button = QPushButton("Default") # add self.add = QLabel("Add Elements:") self.add_edit = QElementEdit(self, str('')) self.add_button = QPushButton("Add") # remove self.remove = QLabel("Remove Elements:") self.remove_edit = QElementEdit(self, str('')) self.remove_button = QPushButton("Remove") # applies a unique implicitly self.eids = parse_patran_syntax(str(self._default_elements), pound=self.elements_pound) # closing #self.apply_button = QPushButton("Apply") self.ok_button = QPushButton("Close") #self.cancel_button = QPushButton("Cancel") self.set_as_main_button = QPushButton("Set As Main") self.create_group_button = QPushButton('Create New Group') self.delete_group_button = QPushButton('Delete Group') self.name.setEnabled(False) self.name_set.setEnabled(False) self.name_edit.setEnabled(False) self.name_button.setEnabled(False) self.elements.setEnabled(False) self.elements_button.setEnabled(False) self.elements_edit.setEnabled(False) self.add.setEnabled(False) self.add_button.setEnabled(False) self.add_edit.setEnabled(False) self.remove.setEnabled(False) self.remove_button.setEnabled(False) self.remove_edit.setEnabled(False) self.delete_group_button.setEnabled(False) #self.apply_button.setEnabled(False) #self.ok_button.setEnabled(False) def create_layout(self): """displays the menu objects""" grid = QGridLayout() grid.addWidget(self.name, 0, 0) grid.addWidget(self.name_edit, 0, 1) grid.addWidget(self.name_set, 0, 2) grid.addWidget(self.name_button, 0, 3) grid.addWidget(self.elements, 2, 0) grid.addWidget(self.elements_edit, 2, 1) grid.addWidget(self.elements_button, 2, 2) grid.addWidget(self.add, 4, 0) grid.addWidget(self.add_edit, 4, 1) grid.addWidget(self.add_button, 4, 2) grid.addWidget(self.remove, 5, 0) grid.addWidget(self.remove_edit, 5, 1) grid.addWidget(self.remove_button, 5, 2) ok_cancel_box = QHBoxLayout() #ok_cancel_box.addWidget(self.apply_button) ok_cancel_box.addWidget(self.ok_button) #ok_cancel_box.addWidget(self.cancel_button) main_create_delete = QHBoxLayout() main_create_delete.addWidget(self.set_as_main_button) main_create_delete.addWidget(self.create_group_button) main_create_delete.addWidget(self.delete_group_button) vbox = QVBoxLayout() vbox.addWidget(self.table) vbox.addLayout(grid) vbox.addLayout(main_create_delete) vbox.addStretch() vbox.addLayout(ok_cancel_box) self.setLayout(vbox) def on_set_name(self): name = str(self.name_edit.text()).strip() if name not in self.keys: self.name_edit.setStyleSheet("QLineEdit{background: white;}") group = self.out_data[self.active_key] group.name = name self.keys[self.active_key] = name self.recreate_table() elif name != self.keys[self.active_key]: self.name_edit.setStyleSheet("QLineEdit{background: red;}") elif name == self.keys[self.active_key]: self.name_edit.setStyleSheet("QLineEdit{background: white;}") def set_connections(self): self.name_set.clicked.connect(self.on_set_name) self.name_button.clicked.connect(self.on_default_name) self.elements_button.clicked.connect(self.on_default_elements) self.add_button.clicked.connect(self.on_add) self.remove_button.clicked.connect(self.on_remove) self.table.itemClicked.connect(self.on_update_active_key) self.ok_button.clicked.connect(self.on_ok) self.set_as_main_button.clicked.connect(self.on_set_as_main) self.create_group_button.clicked.connect(self.on_create_group) self.delete_group_button.clicked.connect(self.on_delete_group) def on_create_group(self): irow = self.nrows new_key = 'Group %s' % irow while new_key in self.keys: irow += 1 new_key = 'Group %s' % irow irow = self.nrows self.keys.append(new_key) group = Group(new_key, element_str='', elements_pound=self.elements_pound, editable=True) self.out_data[irow] = group self.table.reset() self.table.addItems(self.keys) self.nrows += 1 #---------------------------------- # update internal parameters #self.out_data = items if self.imain > self.active_key: self.imain += 1 #make the new group the default self.active_key = self.nrows - 1 self.keys = [ group.name for key, group in sorted(iteritems(self.out_data)) if isinstance(key, int) ] self.recreate_table() def recreate_table(self): # update gui self.table.clear() self.table.addItems(self.keys) item = self.table.item(self.imain) bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) item.setFont(bold) self.table.update() # update key name = self.keys[self.active_key] self._update_active_key_by_name(name) def on_delete_group(self): if self.active_key == 0: return #self.deleted_groups.add(self.imain) items = {} j = 0 for i, key in sorted(iteritems(self.out_data)): if isinstance(i, int): continue if i != self.active_key: items[j] = key j += 1 # update internal parameters self.out_data = items if self.imain >= self.active_key: self.imain = max(0, self.imain - 1) self.active_key = max(0, self.active_key - 1) self.nrows -= 1 self.keys = [group.name for key, group in sorted(iteritems(items))] self.recreate_table() # update key name = self.keys[self.active_key] self._update_active_key_by_name(name) def on_set_as_main(self): bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) normal = QtGui.QFont() normal.setBold(False) normal.setItalic(False) obj = self.table.item(self.imain) obj.setFont(normal) self.imain = self.active_key obj = self.table.item(self.imain) obj.setFont(bold) group = self.out_data[self.imain] self._default_elements = group.element_str self._default_name = group.name self.on_update_main() def on_update_main(self): """adds/removes the elements to the main actor when add/remove is pressed""" group = self.out_data[self.imain] if self._default_name == group.name and self.win_parent is not None: # we're not testing the menu self.win_parent.post_group(group) def closeEvent(self, event): self.out_data['close'] = True event.accept() def on_add(self): eids, is_valid = self.check_patran_syntax(self.add_edit, pound=self.elements_pound) #adict, is_valid = self.check_patran_syntax_dict(self.add_edit) if not is_valid: #self.add_edit.setStyleSheet("QLineEdit{background: red;}") return self.eids = unique(hstack([self.eids, eids])) #self.eids = _add(adict, ['e', 'elem', 'element'], self.eids) #self.cids = _add(adict, ['c', 'cid', 'coord'], self.cids) self._apply_cids_eids() self.add_edit.clear() self.add_edit.setStyleSheet("QLineEdit{background: white;}") self.on_update_main() def _apply_cids_eids(self): #ctext = _get_collapsed_text(self.cids) etext = _get_collapsed_text(self.eids) #self.coords_edit.setText(str(ctext.lstrip())) self.elements_edit.setText(str(etext.lstrip())) self.out_data[self.active_key].element_ids = self.eids def on_remove(self): eids, is_valid = self.check_patran_syntax(self.remove_edit) #adict, is_valid = self.check_patran_syntax_dict(self.remove_edit) if not is_valid: #self.remove_edit.setStyleSheet("QLineEdit{background: red;}") return #self.eids = _remove(adict, ['e', 'elem', 'element'], self.eids) #self.cids = _remove(adict, ['c', 'cid', 'coord'], self.cids) self.eids = setdiff1d(self.eids, eids) self._apply_cids_eids() self.remove_edit.clear() self.remove_edit.setStyleSheet("QLineEdit{background: white;}") self.on_update_main() def on_default_name(self): name = str(self._default_name) self.name_edit.setText(name) self.name_edit.setStyleSheet("QLineEdit{background: white;}") def on_default_elements(self): element_str = str(self._default_elements) self.elements_edit.setText(element_str) self.elements_edit.setStyleSheet("QLineEdit{background: white;}") group = self.out_data[self.active_key] group.element_str = element_str def check_name(self, cell): cell_value = cell.text() try: text = str(cell_value).strip() except UnicodeEncodeError: cell.setStyleSheet("QLineEdit{background: red;}") return None, False if len(text): cell.setStyleSheet("QLineEdit{background: white;}") return text, True else: cell.setStyleSheet("QLineEdit{background: red;}") return None, False if self._default_name != text: if self._default_name in self.out_data: cell.setStyleSheet("QLineEdit{background: white;}") return text, True else: cell.setStyleSheet("QLineEdit{background: red;}") return None, False def on_validate(self): name, flag0 = self.check_name(self.name_edit) elements, flag1 = self.check_patran_syntax(self.elements_edit, pound=self.elements_pound) #coords_value, flag2 = self.check_patran_syntax(self.coords_edit, #pound=self.coords_pound) if all([flag0, flag1]): self._default_name = name self._default_elements = self.eids self.out_data['clicked_ok'] = True self.out_data['close'] = True return True return False def on_apply(self, force=False): passed = self.on_validate() if passed or force: self.win_parent._apply_modify_groups(self.out_data) return passed def on_ok(self): passed = self.on_apply() if passed: self.close() #self.destroy() def on_cancel(self): self.out_data['close'] = True self.close() def on_update_active_key(self, index): self.update_active_key(index) #str(index.text()) def update_active_key(self, index): #old_obj = self.out_data[self.imain] name = str(index.text()) self._update_active_key_by_name(name) def _update_active_key_by_name(self, name): if name in self.keys: self.active_key = self.keys.index(name) else: # we (hopefully) just removed a row #self.active_key = self.keys[self.active_key] pass self.name_edit.setText(name) obj = self.out_data[self.active_key] self.eids = parse_patran_syntax(obj.element_str, pound=obj.elements_pound) self._default_elements = obj.element_str self._default_name = name self._apply_cids_eids() self.set_as_main_button.setEnabled(True) if name in ['main', 'anti-main']: self.name.setEnabled(False) self.name_set.setEnabled(False) self.name_edit.setEnabled(False) self.name_button.setEnabled(False) self.elements.setEnabled(False) self.elements_button.setEnabled(False) self.elements_edit.setEnabled(False) self.add.setEnabled(False) self.add_button.setEnabled(False) self.add_edit.setEnabled(False) self.remove.setEnabled(False) self.remove_button.setEnabled(False) self.remove_edit.setEnabled(False) self.delete_group_button.setEnabled(False) if name == 'anti-main': self.set_as_main_button.setEnabled(False) #self.apply_button.setEnabled(False) #self.ok_button.setEnabled(False) else: self.name.setEnabled(True) self.name_set.setEnabled(True) self.name_edit.setEnabled(True) self.name_button.setEnabled(True) self.elements.setEnabled(True) self.elements_button.setEnabled(True) self.add.setEnabled(True) self.add_button.setEnabled(True) self.add_edit.setEnabled(True) self.remove.setEnabled(True) self.remove_button.setEnabled(True) self.remove_edit.setEnabled(True) self.delete_group_button.setEnabled(True)
class SelectedLinesWidget(QWidget): """ Widget to show and enable lines to be selected inp : LineList Input LineList init_select : str or list of indices str -- 'All' """ def __init__(self, inp, parent=None, init_select=None, plot_widget=None): """ """ super(SelectedLinesWidget, self).__init__(parent) self.parent = parent # Line list Table if isinstance(inp, LineList): self.lines = inp._data self.llst = inp elif isinstance(inp, Table): raise ValueError('SelectedLineWidget: DEPRECATED') else: raise ValueError('SelectedLineWidget: Wrong type of input') self.plot_widget = plot_widget # Create the line list line_label = QLabel('Lines:') self.lines_widget = QListWidget(self) self.lines_widget.setSelectionMode(QAbstractItemView.MultiSelection) # Initialize list self.item_flg = 0 self.init_list() # Initial selection if init_select is None: self.selected = [0] elif init_select == 'All': self.selected = [] for ii in range(self.lines_widget.count()): self.lines_widget.item(ii).setSelected(True) self.selected.append(ii) else: self.selected = init_select if len(self.selected) == 0: self.selected = [0] for iselect in self.selected: self.lines_widget.item(iselect).setSelected(True) self.lines_widget.scrollToItem(self.lines_widget.item( self.selected[0])) # Events self.lines_widget.itemSelectionChanged.connect(self.on_item_change) # Layout vbox = QVBoxLayout() vbox.addWidget(line_label) vbox.addWidget(self.lines_widget) self.setLayout(vbox) def init_list(self): nlin = len(self.lines['wrest']) for ii in range(nlin): self.lines_widget.addItem('{:s} :: {:.3f} :: {}'.format( self.lines['name'][ii], self.lines['wrest'][ii], self.lines['f'][ii])) def on_item_change(self): #,item): # For big changes if self.item_flg == 1: return all_items = [ self.lines_widget.item(ii) for ii in range(self.lines_widget.count()) ] sel_items = self.lines_widget.selectedItems() self.selected = [all_items.index(isel) for isel in sel_items] self.selected.sort() #QtCore.pyqtRemoveInputHook() #xdb.set_trace() #QtCore.pyqtRestoreInputHook() # Update llist try: self.plot_widget.llist['show_line'] = self.selected except AttributeError: if self.parent is not None: self.parent.updated_slines(self.selected) return else: self.plot_widget.on_draw() def on_list_change(self, llist): # Clear if not isinstance(llist, LineList): raise ValueError('Expecting LineList!!') self.item_flg = 1 self.lines = llist._data self.llst = llist self.lines_widget.clear() # Initialize self.init_list() # Set selected for iselect in self.selected: self.lines_widget.item(iselect).setSelected(True) self.lines_widget.scrollToItem(self.lines_widget.item( self.selected[0])) self.item_flg = 0
class CheckList(QWidget): def __init__(self, model, label="", help_link="", custom_filter_button=None): """ :param custom_filter_button: if needed, add a button that opens a custom filter menu. Useful when search alone isn't enough to filter the list. :type custom_filter_button: QToolButton """ QWidget.__init__(self) self._model = model if help_link != "": addHelpToWidget(self, help_link) layout = QVBoxLayout() self._createCheckButtons() self._list = QListWidget() self._list.setContextMenuPolicy(Qt.CustomContextMenu) self._list.setSelectionMode(QAbstractItemView.ExtendedSelection) self._search_box = SearchBox() check_button_layout = QHBoxLayout() check_button_layout.setContentsMargins(0, 0, 0, 0) check_button_layout.setSpacing(0) check_button_layout.addWidget(QLabel(label)) check_button_layout.addStretch(1) check_button_layout.addWidget(self._checkAllButton) check_button_layout.addWidget(self._uncheckAllButton) layout.addLayout(check_button_layout) layout.addWidget(self._list) """ Inserts the custom filter button, if provided. The caller is responsible for all related actions. """ if custom_filter_button is not None: search_bar_layout = QHBoxLayout() search_bar_layout.addWidget(self._search_box) search_bar_layout.addWidget(custom_filter_button) layout.addLayout(search_bar_layout) else: layout.addWidget(self._search_box) self.setLayout(layout) self._checkAllButton.clicked.connect(self.checkAll) self._uncheckAllButton.clicked.connect(self.uncheckAll) self._list.itemChanged.connect(self.itemChanged) self._search_box.filterChanged.connect(self.filterList) self._list.customContextMenuRequested.connect(self.showContextMenu) self._model.selectionChanged.connect(self.modelChanged) self._model.modelChanged.connect(self.modelChanged) self.modelChanged() def _createCheckButtons(self): self._checkAllButton = QToolButton() self._checkAllButton.setIcon(resourceIcon("check.svg")) self._checkAllButton.setIconSize(QSize(16, 16)) self._checkAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly) self._checkAllButton.setAutoRaise(True) self._checkAllButton.setToolTip("Select all") self._uncheckAllButton = QToolButton() self._uncheckAllButton.setIcon(resourceIcon("checkbox_outline.svg")) self._uncheckAllButton.setIconSize(QSize(16, 16)) self._uncheckAllButton.setToolButtonStyle(Qt.ToolButtonIconOnly) self._uncheckAllButton.setAutoRaise(True) self._uncheckAllButton.setToolTip("Unselect all") def itemChanged(self, item): """@type item: QListWidgetItem""" if item.checkState() == Qt.Checked: self._model.selectValue(str(item.text())) elif item.checkState() == Qt.Unchecked: self._model.unselectValue(str(item.text())) else: raise AssertionError("Unhandled checkstate!") def modelChanged(self): self._list.clear() items = self._model.getList() for item in items: list_item = QListWidgetItem(item) list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable) if self._model.isValueSelected(item): list_item.setCheckState(Qt.Checked) else: list_item.setCheckState(Qt.Unchecked) self._list.addItem(list_item) self.filterList(self._search_box.filter()) def setSelectionEnabled(self, enabled): self.setEnabled(enabled) self._checkAllButton.setEnabled(enabled) self._uncheckAllButton.setEnabled(enabled) def filterList(self, filter): filter = filter.lower() for index in range(0, self._list.count()): item = self._list.item(index) text = str(item.text()).lower() if filter == "": item.setHidden(False) elif filter in text: item.setHidden(False) else: item.setHidden(True) def checkAll(self): """ Checks all visible items in the list. """ for index in range(0, self._list.count()): item = self._list.item(index) if not item.isHidden(): self._model.selectValue(str(item.text())) def uncheckAll(self): """ Unchecks all items in the list, visible or not """ self._model.unselectAll() def checkSelected(self): items = [] for item in self._list.selectedItems(): items.append(str(item.text())) for item in items: self._model.selectValue(item) def uncheckSelected(self): items = [] for item in self._list.selectedItems(): items.append(str(item.text())) for item in items: self._model.unselectValue(item) def showContextMenu(self, point): p = self._list.mapToGlobal(point) menu = QMenu() check_selected = menu.addAction("Check selected") uncheck_selected = menu.addAction("Uncheck selected") menu.addSeparator() clear_selection = menu.addAction("Clear selection") selected_item = menu.exec_(p) if selected_item == check_selected: self.checkSelected() elif selected_item == uncheck_selected: self.uncheckSelected() elif selected_item == clear_selection: self._list.clearSelection()
class PathManager(QDialog): """Path manager dialog.""" redirect_stdio = Signal(bool) sig_path_changed = Signal(object) def __init__(self, parent, path=None, read_only_path=None, not_active_path=None, sync=True): """Path manager dialog.""" super(PathManager, self).__init__(parent) assert isinstance(path, (tuple, None)) self.path = path or () self.read_only_path = read_only_path or () self.not_active_path = not_active_path or () self.last_path = getcwd_or_home() self.original_path_dict = None # Widgets self.add_button = None self.remove_button = None self.movetop_button = None self.moveup_button = None self.movedown_button = None self.movebottom_button = None self.sync_button = None self.selection_widgets = [] self.top_toolbar_widgets = self._setup_top_toolbar() self.bottom_toolbar_widgets = self._setup_bottom_toolbar() self.listwidget = QListWidget(self) self.bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.button_ok = self.bbox.button(QDialogButtonBox.Ok) # Widget setup # Destroying the C++ object right after closing the dialog box, # otherwise it may be garbage-collected in another QThread # (e.g. the editor's analysis thread in Spyder), thus leading to # a segmentation fault on UNIX or an application crash on Windows self.setAttribute(Qt.WA_DeleteOnClose) self.setWindowTitle(_("PYTHONPATH manager")) self.setWindowIcon(ima.icon('pythonpath')) self.resize(500, 300) self.sync_button.setVisible(os.name == 'nt' and sync) # Layouts top_layout = QHBoxLayout() self._add_widgets_to_layout(self.top_toolbar_widgets, top_layout) bottom_layout = QHBoxLayout() self._add_widgets_to_layout(self.bottom_toolbar_widgets, bottom_layout) bottom_layout.addWidget(self.bbox) layout = QVBoxLayout() layout.addLayout(top_layout) layout.addWidget(self.listwidget) layout.addLayout(bottom_layout) self.setLayout(layout) # Signals self.listwidget.currentRowChanged.connect(lambda x: self.refresh()) self.listwidget.itemChanged.connect(lambda x: self.refresh()) self.bbox.accepted.connect(self.accept) self.bbox.rejected.connect(self.reject) # Setup self.setup() def _add_widgets_to_layout(self, widgets, layout): """Helper to add toolbar widgets to top and bottom layout.""" layout.setAlignment(Qt.AlignLeft) for widget in widgets: if widget is None: layout.addStretch(1) else: layout.addWidget(widget) def _setup_top_toolbar(self): """Create top toolbar and actions.""" self.movetop_button = create_toolbutton( self, text=_("Move to top"), icon=ima.icon('2uparrow'), triggered=lambda: self.move_to(absolute=0), text_beside_icon=True) self.moveup_button = create_toolbutton( self, text=_("Move up"), icon=ima.icon('1uparrow'), triggered=lambda: self.move_to(relative=-1), text_beside_icon=True) self.movedown_button = create_toolbutton( self, text=_("Move down"), icon=ima.icon('1downarrow'), triggered=lambda: self.move_to(relative=1), text_beside_icon=True) self.movebottom_button = create_toolbutton( self, text=_("Move to bottom"), icon=ima.icon('2downarrow'), triggered=lambda: self.move_to(absolute=1), text_beside_icon=True) toolbar = [ self.movetop_button, self.moveup_button, self.movedown_button, self.movebottom_button ] self.selection_widgets.extend(toolbar) return toolbar def _setup_bottom_toolbar(self): """Create bottom toolbar and actions.""" self.add_button = create_toolbutton( self, text=_('Add path'), icon=ima.icon('edit_add'), triggered=lambda x: self.add_path(), text_beside_icon=True) self.remove_button = create_toolbutton( self, text=_('Remove path'), icon=ima.icon('edit_remove'), triggered=lambda x: self.remove_path(), text_beside_icon=True) self.sync_button = create_toolbutton( self, text=_("Synchronize..."), icon=ima.icon('fileimport'), triggered=self.synchronize, tip=_("Synchronize Spyder's path list with PYTHONPATH " "environment variable"), text_beside_icon=True) self.selection_widgets.append(self.remove_button) return [self.add_button, self.remove_button, None, self.sync_button] def _create_item(self, path): """Helper to create a new list item.""" item = QListWidgetItem(path) item.setIcon(ima.icon('DirClosedIcon')) if path in self.read_only_path: item.setFlags(Qt.NoItemFlags | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Checked) elif path in self.not_active_path: item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Unchecked) else: item.setFlags(item.flags() | Qt.ItemIsUserCheckable) item.setCheckState(Qt.Checked) return item @property def editable_bottom_row(self): """Maximum bottom row count that is editable.""" read_only_count = len(self.read_only_path) if read_only_count == 0: max_row = self.listwidget.count() - 1 else: max_row = self.listwidget.count() - read_only_count - 1 return max_row def setup(self): """Populate list widget.""" self.listwidget.clear() for path in self.path + self.read_only_path: item = self._create_item(path) self.listwidget.addItem(item) self.listwidget.setCurrentRow(0) self.original_path_dict = self.get_path_dict() self.refresh() @Slot() def synchronize(self): """ Synchronize Spyder's path list with PYTHONPATH environment variable Only apply to: current user, on Windows platforms. """ answer = QMessageBox.question( self, _("Synchronize"), _("This will synchronize Spyder's path list with " "<b>PYTHONPATH</b> environment variable for the current user, " "allowing you to run your Python modules outside Spyder " "without having to configure sys.path. " "<br>" "Do you want to clear contents of PYTHONPATH before " "adding Spyder's path list?"), QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel) if answer == QMessageBox.Cancel: return elif answer == QMessageBox.Yes: remove = True else: remove = False from spyder.utils.environ import (get_user_env, listdict2envdict, set_user_env) env = get_user_env() # Includes read only paths active_path = tuple(k for k, v in self.get_path_dict(True).items() if v) if remove: ppath = active_path else: ppath = env.get('PYTHONPATH', []) if not isinstance(ppath, list): ppath = [ppath] ppath = tuple(p for p in ppath if p not in active_path) ppath = ppath + active_path env['PYTHONPATH'] = list(ppath) set_user_env(listdict2envdict(env), parent=self) def get_path_dict(self, read_only=False): """ Return an ordered dict with the path entries as keys and the active state as the value. If `read_only` is True, the read_only entries are also included. `read_only` entry refers to the project path entry. """ odict = OrderedDict() for row in range(self.listwidget.count()): item = self.listwidget.item(row) path = item.text() if path in self.read_only_path and not read_only: continue odict[path] = item.checkState() == Qt.Checked return odict def refresh(self): """Refresh toolbar widgets.""" enabled = self.listwidget.currentItem() is not None for widget in self.selection_widgets: widget.setEnabled(enabled) # Disable buttons based on row row = self.listwidget.currentRow() disable_widgets = [] # Move up/top disabled for top item if row == 0: disable_widgets.extend([self.movetop_button, self.moveup_button]) # Move down/bottom disabled for bottom item if row == self.editable_bottom_row: disable_widgets.extend( [self.movebottom_button, self.movedown_button]) for widget in disable_widgets: widget.setEnabled(False) self.sync_button.setEnabled(self.listwidget.count() > 0) # Ok button only enabled if actual changes occur self.button_ok.setEnabled( self.original_path_dict != self.get_path_dict()) def check_path(self, path): """Check that the path is not a [site|dist]-packages folder.""" if os.name == 'nt': pat = re.compile(r'.*lib/(?:site|dist)-packages.*') else: pat = re.compile(r'.*lib/python.../(?:site|dist)-packages.*') path_norm = path.replace('\\', '/') return pat.match(path_norm) is None @Slot() def add_path(self, directory=None): """ Add path to list widget. If `directory` is provided, the folder dialog is overridden. """ if directory is None: self.redirect_stdio.emit(False) directory = getexistingdirectory(self, _("Select directory"), self.last_path) self.redirect_stdio.emit(True) if PY2: is_unicode = False try: directory.decode('ascii') except (UnicodeEncodeError, UnicodeDecodeError): is_unicode = True if is_unicode: QMessageBox.warning( self, _("Add path"), _("You are using Python 2 and the selected path has " "Unicode characters." "<br> " "Therefore, this path will not be added."), QMessageBox.Ok) return directory = osp.abspath(directory) self.last_path = directory if directory in self.get_path_dict(): item = self.listwidget.findItems(directory, Qt.MatchExactly)[0] item.setCheckState(Qt.Checked) answer = QMessageBox.question( self, _("Add path"), _("This directory is already included in the list." "<br> " "Do you want to move it to the top of it?"), QMessageBox.Yes | QMessageBox.No) if answer == QMessageBox.Yes: item = self.listwidget.takeItem(self.listwidget.row(item)) self.listwidget.insertItem(0, item) self.listwidget.setCurrentRow(0) else: if self.check_path(directory): item = self._create_item(directory) self.listwidget.insertItem(0, item) self.listwidget.setCurrentRow(0) else: answer = QMessageBox.warning( self, _("Add path"), _("This directory cannot be added to the path!" "<br><br>" "If you want to set a different Python interpreter, " "please go to <tt>Preferences > Main interpreter</tt>" "."), QMessageBox.Ok) self.refresh() @Slot() def remove_path(self, force=False): """ Remove path from list widget. If `force` is True, the message box is overridden. """ if self.listwidget.currentItem(): if not force: answer = QMessageBox.warning( self, _("Remove path"), _("Do you really want to remove the selected path?"), QMessageBox.Yes | QMessageBox.No) if force or answer == QMessageBox.Yes: self.listwidget.takeItem(self.listwidget.currentRow()) self.refresh() def move_to(self, absolute=None, relative=None): """Move items of list widget.""" index = self.listwidget.currentRow() if absolute is not None: if absolute: new_index = self.listwidget.count() - 1 else: new_index = 0 else: new_index = index + relative new_index = max(0, min(self.editable_bottom_row, new_index)) item = self.listwidget.takeItem(index) self.listwidget.insertItem(new_index, item) self.listwidget.setCurrentRow(new_index) self.refresh() def current_row(self): """Returns the current row of the list.""" return self.listwidget.currentRow() def set_current_row(self, row): """Set the current row of the list.""" self.listwidget.setCurrentRow(row) def row_check_state(self, row): """Return the checked state for item in row.""" item = self.listwidget.item(row) return item.checkState() def set_row_check_state(self, row, value): """Set the current checked state for item in row.""" item = self.listwidget.item(row) item.setCheckState(value) def count(self): """Return the number of items.""" return self.listwidget.count() def accept(self): """Override Qt method.""" path_dict = self.get_path_dict() if self.original_path_dict != path_dict: self.sig_path_changed.emit(path_dict) super(PathManager, self).accept()
class ApplicationsDialog(QDialog): """Dialog for selection of installed system/user applications.""" def __init__(self, parent=None): """Dialog for selection of installed system/user applications.""" super(ApplicationsDialog, self).__init__(parent=parent) # Widgets self.label = QLabel() self.label_browse = QLabel() self.edit_filter = QLineEdit() self.list = QListWidget() self.button_browse = QPushButton(_('Browse...')) self.button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) self.button_ok = self.button_box.button(QDialogButtonBox.Ok) self.button_cancel = self.button_box.button(QDialogButtonBox.Cancel) # Widget setup self.setWindowTitle(_('Applications')) self.edit_filter.setPlaceholderText(_('Type to filter by name')) self.list.setIconSize(QSize(16, 16)) # FIXME: Use metrics # Layout layout = QVBoxLayout() layout.addWidget(self.label) layout.addWidget(self.edit_filter) layout.addWidget(self.list) layout_browse = QHBoxLayout() layout_browse.addWidget(self.button_browse) layout_browse.addWidget(self.label_browse) layout.addLayout(layout_browse) layout.addSpacing(12) # FIXME: Use metrics layout.addWidget(self.button_box) self.setLayout(layout) # Signals self.edit_filter.textChanged.connect(self.filter) self.button_browse.clicked.connect(lambda x: self.browse()) self.button_ok.clicked.connect(self.accept) self.button_cancel.clicked.connect(self.reject) self.list.currentItemChanged.connect(self._refresh) self._refresh() self.setup() def setup(self, applications=None): """Load installed applications.""" QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) self.list.clear() if applications is None: apps = get_installed_applications() else: apps = applications for app in sorted(apps, key=lambda x: x.lower()): fpath = apps[app] icon = get_application_icon(fpath) item = QListWidgetItem(icon, app) item.setToolTip(fpath) item.fpath = fpath self.list.addItem(item) # FIXME: Use metrics self.list.setMinimumWidth(self.list.sizeHintForColumn(0) + 24) QApplication.restoreOverrideCursor() self._refresh() def _refresh(self): """Refresh the status of buttons on widget.""" self.button_ok.setEnabled(self.list.currentRow() != -1) def browse(self, fpath=None): """Prompt user to select an application not found on the list.""" app = None item = None if sys.platform == 'darwin': if fpath is None: basedir = '/Applications/' filters = _('Applications (*.app)') title = _('Select application') fpath, __ = getopenfilename(self, title, basedir, filters) if fpath and fpath.endswith('.app') and os.path.isdir(fpath): app = os.path.basename(fpath).split('.app')[0] for row in range(self.list.count()): item = self.list.item(row) if app == item.text() and fpath == item.fpath: break else: item = None elif os.name == 'nt': if fpath is None: basedir = 'C:\\' filters = _('Applications (*.exe *.bat *.com)') title = _('Select application') fpath, __ = getopenfilename(self, title, basedir, filters) if fpath: check_1 = fpath.endswith('.bat') and is_text_file(fpath) check_2 = (fpath.endswith(('.exe', '.com')) and not is_text_file(fpath)) if check_1 or check_2: app = os.path.basename(fpath).capitalize().rsplit('.')[0] for row in range(self.list.count()): item = self.list.item(row) if app == item.text() and fpath == item.fpath: break else: item = None else: if fpath is None: basedir = '/' filters = _('Applications (*.desktop)') title = _('Select application') fpath, __ = getopenfilename(self, title, basedir, filters) if fpath and fpath.endswith(('.desktop')) and is_text_file(fpath): entry_data = parse_linux_desktop_entry(fpath) app = entry_data['name'] for row in range(self.list.count()): item = self.list.item(row) if app == item.text() and fpath == item.fpath: break else: item = None if fpath: if item: self.list.setCurrentItem(item) elif app: icon = get_application_icon(fpath) item = QListWidgetItem(icon, app) item.fpath = fpath self.list.addItem(item) self.list.setCurrentItem(item) self.list.setFocus() self._refresh() def filter(self, text): """Filter the list of applications based on text.""" text = self.edit_filter.text().lower().strip() for row in range(self.list.count()): item = self.list.item(row) item.setHidden(text not in item.text().lower()) self._refresh() def set_extension(self, extension): """Set the extension on the label of the dialog.""" self.label.setText( _('Choose the application for files of type ') + extension) @property def application_path(self): """Return the selected application path to executable.""" item = self.list.currentItem() path = item.fpath if item else '' return path @property def application_name(self): """Return the selected application name.""" item = self.list.currentItem() text = item.text() if item else '' return text
class HeaderEditDialog(QDialog): # name of the current preset; whether to set this preset as default; list of Columns header_changed = Signal(str, bool, list) def __init__(self, parent, table_header): super().__init__(parent) self.table_header = table_header self.default_preset_name = None self.preset_name = table_header.preset_name self.columns = deepcopy(table_header.columns) self.setupUi() self.update_output() def setupUi(self): self.resize(240, 400) self.vbox = QVBoxLayout(self) self.presetLabel = QLabel(self) self.columnList = QListWidget(self) self.setAsDefaultCheckbox = QCheckBox("Set as default preset", self) self.vbox.addWidget(self.presetLabel) self.vbox.addWidget(self.columnList) self.vbox.addWidget(self.setAsDefaultCheckbox) self.columnList.setDragDropMode(QListWidget.InternalMove) self.columnList.setDefaultDropAction(Qt.MoveAction) self.columnList.setSelectionMode(QListWidget.ExtendedSelection) self.columnList.setAlternatingRowColors(True) self.columnList.installEventFilter(self) self.columnList.setContextMenuPolicy(Qt.CustomContextMenu) self.columnList.customContextMenuRequested.connect(self.open_menu) self.columnList.model().rowsMoved.connect(self.read_columns_from_list) # for a dumb qss hack to make selected checkboxes not white on a light theme self.columnList.setObjectName("ColumnList") buttons = QDialogButtonBox.Reset | QDialogButtonBox.Save | QDialogButtonBox.Cancel self.buttonBox = QDialogButtonBox(buttons, self) self.vbox.addWidget(self.buttonBox) self.buttonBox.accepted.connect(self.accept) self.buttonBox.rejected.connect(self.reject) self.resetButton = self.buttonBox.button(QDialogButtonBox.Reset) self.resetButton.clicked.connect(self.reset_to_stock) def eventFilter(self, object, event): if event.type() == QEvent.KeyPress: if event.key() == Qt.Key_Space or event.key() == Qt.Key_Return: self.toggle_selected_columns() return True if event.key() == Qt.Key_Delete: self.delete_selected() return True return False def update_output(self): self.presetLabel.setText("Preset: {}".format(self.preset_name)) self.setAsDefaultCheckbox.setChecked( CONFIG['default_header_preset'] == self.preset_name) self.columnList.clear() for column in self.columns: ColumnListItem(self.columnList, column) def accept(self): self.read_columns_from_list() self.header_changed.emit(self.preset_name, self.setAsDefaultCheckbox.isChecked(), self.columns) self.done(0) def reject(self): self.done(0) def reset_to_stock(self): self.columns = deepcopy(DEFAULT_COLUMNS) self.update_output() def read_columns_from_list(self): new_columns = [] for i in range(self.columnList.count()): item = self.columnList.item(i) new_columns.append(item.column) self.columns = new_columns def toggle_selected_columns(self): selected = self.columnList.selectedItems() for item in selected: value_now = item.data(Qt.CheckStateRole) item.setData(Qt.CheckStateRole, not value_now) self.columnList.reset( ) # @Improvement: is there a better way to update QListWidget? def open_menu(self, position): menu = QMenu(self) preset_menu = menu.addMenu('Presets') preset_menu.addAction('New preset', self.new_preset_dialog) preset_menu.addSeparator() preset_names = CONFIG.get_header_presets() if len(preset_names) == 0: action = preset_menu.addAction('No presets') action.setEnabled(False) else: delete_menu = menu.addMenu('Delete preset') for name in preset_names: preset_menu.addAction(name, partial(self.load_preset, name)) delete_menu.addAction(name, partial(self.delete_preset, name)) menu.addSeparator() menu.addAction('New column...', self.create_new_column_dialog) if len(self.columnList.selectedIndexes()) > 0: menu.addAction('Delete selected', self.delete_selected) menu.popup(self.columnList.viewport().mapToGlobal(position)) def load_preset(self, name): new_columns = CONFIG.load_header_preset(name) if not new_columns: return self.columns = new_columns self.preset_name = name self.update_output() def new_preset_dialog(self): d = QInputDialog(self) d.setLabelText('Enter the new name for the new preset:') d.setWindowTitle('Create new preset') d.textValueSelected.connect(self.create_new_preset) d.open() def create_new_preset(self, name): if name in CONFIG.get_header_presets(): show_warning_dialog( self, "Preset creation error", 'Preset named "{}" already exists.'.format(name)) return if len(name.strip()) == 0: show_warning_dialog( self, "Preset creation error", 'This preset name is not allowed.'.format(name)) return self.preset_name = name self.update_output() CONFIG.save_header_preset(name, self.columns) def delete_preset(self, name): CONFIG.delete_header_preset(name) if name == self.preset_name: self.columns = deepcopy(DEFAULT_COLUMNS) self.update_output() def create_new_column_dialog(self): d = CreateNewColumnDialog(self) d.add_new_column.connect(self.add_new_column) d.setWindowTitle('Create new column') d.open() def add_new_column(self, name, title): new_column = Column(name, title) # if the last column is message, insert this column before it (I think that makes sense?) if len(self.columns) == 0: self.columns.append(new_column) elif self.columns[-1].name in ('message', 'msg'): self.columns.insert(-1, new_column) else: self.columns.append(new_column) self.update_output() def delete_selected(self): selected = self.columnList.selectedItems() for item in selected: self.columnList.takeItem(self.columnList.row(item)) self.read_columns_from_list() self.update_output()
class FindOptions(QWidget): """Find widget with options""" REGEX_INVALID = "background-color:rgb(255, 175, 90);" find = Signal() stop = Signal() redirect_stdio = Signal(bool) def __init__(self, parent, search_text, search_text_regexp, search_path, exclude, exclude_idx, exclude_regexp, supported_encodings, in_python_path, more_options, case_sensitive, external_path_history): QWidget.__init__(self, parent) if search_path is None: search_path = getcwd() self.path = '' self.project_path = None self.file_path = None self.external_path = None self.external_path_history = external_path_history if not isinstance(search_text, (list, tuple)): search_text = [search_text] if not isinstance(search_path, (list, tuple)): search_path = [search_path] if not isinstance(exclude, (list, tuple)): exclude = [exclude] if not isinstance(external_path_history, (list, tuple)): external_path_history = [external_path_history] self.supported_encodings = supported_encodings # Layout 1 hlayout1 = QHBoxLayout() self.search_text = PatternComboBox(self, search_text, _("Search pattern")) self.edit_regexp = create_toolbutton(self, icon=ima.icon('advanced'), tip=_('Regular expression')) self.case_button = create_toolbutton(self, icon=get_icon("upper_lower.png"), tip=_("Case Sensitive")) self.case_button.setCheckable(True) self.case_button.setChecked(case_sensitive) self.edit_regexp.setCheckable(True) self.edit_regexp.setChecked(search_text_regexp) self.more_widgets = () self.more_options = create_toolbutton(self, toggled=self.toggle_more_options) self.more_options.setCheckable(True) self.more_options.setChecked(more_options) self.ok_button = create_toolbutton(self, text=_("Search"), icon=ima.icon('find'), triggered=lambda: self.find.emit(), tip=_("Start search"), text_beside_icon=True) self.ok_button.clicked.connect(self.update_combos) self.stop_button = create_toolbutton(self, text=_("Stop"), icon=ima.icon('editclear'), triggered=lambda: self.stop.emit(), tip=_("Stop search"), text_beside_icon=True) self.stop_button.setEnabled(False) for widget in [self.search_text, self.edit_regexp, self.case_button, self.ok_button, self.stop_button, self.more_options]: hlayout1.addWidget(widget) # Layout 2 hlayout2 = QHBoxLayout() self.exclude_pattern = PatternComboBox(self, exclude, _("Excluded filenames pattern")) if exclude_idx is not None and exclude_idx >= 0 \ and exclude_idx < self.exclude_pattern.count(): self.exclude_pattern.setCurrentIndex(exclude_idx) self.exclude_regexp = create_toolbutton(self, icon=ima.icon('advanced'), tip=_('Regular expression')) self.exclude_regexp.setCheckable(True) self.exclude_regexp.setChecked(exclude_regexp) exclude_label = QLabel(_("Exclude:")) exclude_label.setBuddy(self.exclude_pattern) for widget in [exclude_label, self.exclude_pattern, self.exclude_regexp]: hlayout2.addWidget(widget) # Layout 3 hlayout3 = QHBoxLayout() search_on_label = QLabel(_("Search in:")) self.path_selection_combo = PatternComboBox(self, exclude, _('Search directory')) self.path_selection_combo.setEditable(False) self.path_selection_contents = QListWidget(self.path_selection_combo) self.path_selection_contents.hide() self.path_selection_combo.setModel( self.path_selection_contents.model()) self.path_selection_contents.addItem(_("Current working directory")) item = self.path_selection_contents.item(0) item.setToolTip(_("Search in all files and " "directories present on the" "current Spyder path")) self.path_selection_contents.addItem(_("Project")) item = self.path_selection_contents.item(1) item.setToolTip(_("Search in all files and " "directories present on the" "current project path " "(If opened)")) item.setFlags(item.flags() & ~Qt.ItemIsEnabled) self.path_selection_contents.addItem(_("File").replace('&', '')) item = self.path_selection_contents.item(2) item.setToolTip(_("Search in current opened file")) self.path_selection_contents.addItem(_("Select other directory")) item = self.path_selection_contents.item(3) item.setToolTip(_("Search in other folder present on the file system")) self.path_selection_combo.insertSeparator(3) self.path_selection_combo.insertSeparator(5) for path in external_path_history: item = ExternalPathItem(None, path) self.path_selection_contents.addItem(item) self.path_selection_combo.currentIndexChanged.connect( self.path_selection_changed) hlayout3.addWidget(search_on_label) hlayout3.addWidget(self.path_selection_combo) self.search_text.valid.connect(lambda valid: self.find.emit()) self.exclude_pattern.valid.connect(lambda valid: self.find.emit()) vlayout = QVBoxLayout() vlayout.setContentsMargins(0, 0, 0, 0) vlayout.addLayout(hlayout1) vlayout.addLayout(hlayout2) vlayout.addLayout(hlayout3) self.more_widgets = (hlayout2,) self.toggle_more_options(more_options) self.setLayout(vlayout) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum) @Slot(bool) def toggle_more_options(self, state): for layout in self.more_widgets: for index in range(layout.count()): if state and self.isVisible() or not state: layout.itemAt(index).widget().setVisible(state) if state: icon = ima.icon('options_less') tip = _('Hide advanced options') else: icon = ima.icon('options_more') tip = _('Show advanced options') self.more_options.setIcon(icon) self.more_options.setToolTip(tip) @Slot() def path_selection_changed(self): idx = self.path_selection_combo.currentIndex() if idx == EXTERNAL_PATH: external_path = self.select_directory() if len(external_path) > 0: item = ExternalPathItem(None, external_path) self.path_selection_contents.addItem(item) total_items = (self.path_selection_combo.count() - MAX_PATH_HISTORY) for i in range(6, total_items): self.path_selection_contents.takeItem(i) self.path_selection_combo.setCurrentIndex( self.path_selection_combo.count() - 1) else: self.path_selection_combo.setCurrentIndex(CWD) elif idx > EXTERNAL_PATH: item = self.path_selection_contents.item(idx) self.external_path = item.path def update_combos(self): self.search_text.lineEdit().returnPressed.emit() self.exclude_pattern.lineEdit().returnPressed.emit() def set_search_text(self, text): if text: self.search_text.add_text(text) self.search_text.lineEdit().selectAll() self.search_text.setFocus() def get_options(self, all=False): # Getting options self.search_text.lineEdit().setStyleSheet("") self.exclude_pattern.lineEdit().setStyleSheet("") utext = to_text_string(self.search_text.currentText()) if not utext: return try: texts = [(utext.encode('utf-8'), 'utf-8')] except UnicodeEncodeError: texts = [] for enc in self.supported_encodings: try: texts.append((utext.encode(enc), enc)) except UnicodeDecodeError: pass text_re = self.edit_regexp.isChecked() exclude = to_text_string(self.exclude_pattern.currentText()) exclude_re = self.exclude_regexp.isChecked() case_sensitive = self.case_button.isChecked() python_path = False if not case_sensitive: texts = [(text[0].lower(), text[1]) for text in texts] file_search = False selection_idx = self.path_selection_combo.currentIndex() if selection_idx == CWD: path = self.path elif selection_idx == PROJECT: path = self.project_path elif selection_idx == FILE_PATH: path = self.file_path file_search = True else: path = self.external_path # Finding text occurrences if not exclude_re: exclude = fnmatch.translate(exclude) else: try: exclude = re.compile(exclude) except Exception: exclude_edit = self.exclude_pattern.lineEdit() exclude_edit.setStyleSheet(self.REGEX_INVALID) return None if text_re: try: texts = [(re.compile(x[0]), x[1]) for x in texts] except Exception: self.search_text.lineEdit().setStyleSheet(self.REGEX_INVALID) return None if all: search_text = [to_text_string(self.search_text.itemText(index)) for index in range(self.search_text.count())] exclude = [to_text_string(self.exclude_pattern.itemText(index)) for index in range(self.exclude_pattern.count())] path_history = [to_text_string( self.path_selection_contents.item(index)) for index in range( 6, self.path_selection_combo.count())] exclude_idx = self.exclude_pattern.currentIndex() more_options = self.more_options.isChecked() return (search_text, text_re, [], exclude, exclude_idx, exclude_re, python_path, more_options, case_sensitive, path_history) else: return (path, file_search, exclude, texts, text_re, case_sensitive) @Slot() def select_directory(self): """Select directory""" self.redirect_stdio.emit(False) directory = getexistingdirectory(self, _("Select directory"), self.path) if directory: directory = to_text_string(osp.abspath(to_text_string(directory))) self.redirect_stdio.emit(True) return directory def set_directory(self, directory): self.path = to_text_string(osp.abspath(to_text_string(directory))) def set_project_path(self, path): self.project_path = to_text_string(osp.abspath(to_text_string(path))) item = self.path_selection_contents.item(PROJECT) item.setFlags(item.flags() | Qt.ItemIsEnabled) def disable_project_search(self): item = self.path_selection_contents.item(PROJECT) item.setFlags(item.flags() & ~Qt.ItemIsEnabled) self.project_path = None def set_file_path(self, path): self.file_path = path def keyPressEvent(self, event): """Reimplemented to handle key events""" ctrl = event.modifiers() & Qt.ControlModifier shift = event.modifiers() & Qt.ShiftModifier if event.key() in (Qt.Key_Enter, Qt.Key_Return): self.find.emit() elif event.key() == Qt.Key_F and ctrl and shift: # Toggle find widgets self.parent().toggle_visibility.emit(not self.isVisible()) else: QWidget.keyPressEvent(self, event)
class GroupsModify(PyDialog): """ +-------------------------------+ | Groups : Modify | +-------------------------------+ | | | Name xxx Default | | Nodes xxx Default Show | | Color xxx Default | | Add xxx Add Show | | Remove xxx Remove Show | | | | Set OK Cancel | +-------------------------------+ """ def __init__(self, data, win_parent=None, model_name=None, group_active='main'): super(GroupsModify, self).__init__(data, win_parent) self.set_font_size(data['font_size']) self._updated_groups = False self.model_name = model_name self.actors = [] #self.out_data = data #print(data) self.keys = get_groups_sorted_by_name(data) self.active_key = self.keys.index(group_active) group_obj = data[self.active_key] unused_name = group_obj.name self.imain = 0 self.nrows = len(self.keys) self._default_name = group_obj.name self._default_elements = group_obj.element_str self.elements_pound = group_obj.elements_pound self.table = QListWidget(parent=None) self.table.clear() self.table.addItems(self.keys) self.setWindowTitle('Groups: Modify') self.create_widgets() self.create_layout() self.set_connections() self.on_set_as_main() def create_widgets(self): """creates the menu objects""" #icon = QtGui.QPixmap(os.path.join(ICON_PATH, 'node.png')) #icon = QtGui.QPixmap(os.path.join(ICON_PATH, 'element.png')) # Name self.pick_style_label = QLabel('Pick Style:') #self.pick_node_button = QPushButton('Node') self.pick_element_button = QPushButton('Element') self.pick_area_button = QPushButton('Area') #self.pick_node_button.setIcon(icon) #self.pick_area_button.setIcon(icon) # Name self.name_label = QLabel('Name:') self.name_set = QPushButton('Set') self.name_edit = QLineEdit(str(self._default_name).strip()) self.name_button = QPushButton('Default') # elements self.elements_label = QLabel('Element IDs:') self.elements_edit = QLineEdit(str(self._default_elements).strip()) self.elements_button = QPushButton('Default') self.elements_highlight_button = QPushButton('Show') # add self.add_label = QLabel('Add Elements:') self.add_edit = QElementEdit(self, self.model_name, pick_style='area') self.add_button = QPushButton('Add') self.add_highlight_button = QPushButton('Show') # remove self.remove_label = QLabel('Remove Elements:') self.remove_edit = QElementEdit(self, self.model_name, pick_style='area') self.remove_button = QPushButton('Remove') self.remove_highlight_button = QPushButton('Show') # applies a unique implicitly self.eids = parse_patran_syntax(str(self._default_elements), pound=self.elements_pound) # closing #self.apply_button = QPushButton('Apply') self.ok_button = QPushButton('Close') #self.cancel_button = QPushButton('Cancel') self.set_as_main_button = QPushButton('Set As Main') self.create_group_button = QPushButton('Create New Group') self.delete_group_button = QPushButton('Delete Group') self.name_label.setEnabled(False) self.name_set.setEnabled(False) self.name_edit.setEnabled(False) self.name_button.setEnabled(False) self.elements_label.setEnabled(False) self.elements_button.setEnabled(False) self.elements_edit.setEnabled(False) self.elements_highlight_button.setEnabled(False) self.add_label.setEnabled(False) self.add_button.setEnabled(False) self.add_edit.setEnabled(False) self.add_highlight_button.setEnabled(False) self.remove_label.setEnabled(False) self.remove_button.setEnabled(False) self.remove_edit.setEnabled(False) self.remove_highlight_button.setEnabled(False) #self.apply_button.setEnabled(False) #self.ok_button.setEnabled(False) def create_layout(self): """displays the menu objects""" hbox = QHBoxLayout() hbox.addWidget(self.pick_style_label) hbox.addWidget(self.pick_element_button) hbox.addWidget(self.pick_area_button) hbox.addStretch() grid = QGridLayout() irow = 0 grid.addWidget(self.name_label, irow, 0) grid.addWidget(self.name_edit, irow, 1) grid.addWidget(self.name_set, irow, 2) grid.addWidget(self.name_button, irow, 3) irow += 1 grid.addWidget(self.elements_label, irow, 0) grid.addWidget(self.elements_edit, irow, 1) grid.addWidget(self.elements_button, irow, 2) grid.addWidget(self.elements_highlight_button, irow, 3) irow += 1 grid.addWidget(self.add_label, irow, 0) grid.addWidget(self.add_edit, irow, 1) grid.addWidget(self.add_button, irow, 2) grid.addWidget(self.add_highlight_button, irow, 3) irow += 1 grid.addWidget(self.remove_label, irow, 0) grid.addWidget(self.remove_edit, irow, 1) grid.addWidget(self.remove_button, irow, 2) grid.addWidget(self.remove_highlight_button, irow, 3) irow += 1 ok_cancel_box = QHBoxLayout() #ok_cancel_box.addWidget(self.apply_button) ok_cancel_box.addWidget(self.ok_button) #ok_cancel_box.addWidget(self.cancel_button) main_create_delete = QHBoxLayout() main_create_delete.addWidget(self.set_as_main_button) main_create_delete.addWidget(self.create_group_button) main_create_delete.addWidget(self.delete_group_button) vbox = QVBoxLayout() vbox.addWidget(self.table) vbox.addLayout(hbox) vbox.addLayout(grid) vbox.addLayout(main_create_delete) vbox.addStretch() vbox.addLayout(ok_cancel_box) self.setLayout(vbox) def on_set_name(self): self.remove_highlight_actor() name = str(self.name_edit.text()).strip() if name not in self.keys: self.name_edit.setStyleSheet("QLineEdit{background: white;}") group = self.out_data[self.active_key] group.name = name self.keys[self.active_key] = name self.recreate_table() elif name != self.keys[self.active_key]: self.name_edit.setStyleSheet('QLineEdit{background: red;}') elif name == self.keys[self.active_key]: self.name_edit.setStyleSheet('QLineEdit{background: white;}') def on_pick_element(self): self.add_edit.pick_style = 'single' self.remove_edit.pick_style = 'single' def on_pick_area(self): self.add_edit.pick_style = 'area' self.remove_edit.pick_style = 'area' def set_connections(self): """creates the actions for the menu""" self.pick_element_button.clicked.connect(self.on_pick_element) self.pick_area_button.clicked.connect(self.on_pick_area) self.name_set.clicked.connect(self.on_set_name) self.name_button.clicked.connect(self.on_default_name) self.elements_button.clicked.connect(self.on_default_elements) self.elements_highlight_button.clicked.connect( self.on_highlight_elements) self.add_button.clicked.connect(self.on_add) self.add_highlight_button.clicked.connect(self.on_highlight_add) self.remove_button.clicked.connect(self.on_remove) self.remove_highlight_button.clicked.connect(self.on_highlight_remove) self.table.itemClicked.connect(self.on_update_active_key) self.ok_button.clicked.connect(self.on_ok) self.set_as_main_button.clicked.connect(self.on_set_as_main) self.create_group_button.clicked.connect(self.on_create_group) self.delete_group_button.clicked.connect(self.on_delete_group) def on_create_group(self): self.remove_highlight_actor() irow = self.nrows new_key = f'Group {irow:d}' while new_key in self.keys: irow += 1 new_key = f'Group {irow:d}' irow = self.nrows self.keys.append(new_key) group = Group(new_key, element_str='', elements_pound=self.elements_pound, editable=True) self.out_data[irow] = group self.table.reset() self.table.addItems(self.keys) self.nrows += 1 #---------------------------------- # update internal parameters #self.out_data = items if self.imain > self.active_key: self.imain += 1 #make the new group the default self.active_key = self.nrows - 1 self.keys = get_groups_sorted_by_name(self.out_data) self.recreate_table() def recreate_table(self): # update gui self.table.clear() self.table.addItems(self.keys) item = self.table.item(self.imain) bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) item.setFont(bold) self.table.update() # update key name = self.keys[self.active_key] self._update_active_key_by_name(name) def on_delete_group(self): self.remove_highlight_actor() if self.active_key == 0: return #self.deleted_groups.add(self.imain) items = {} j = 0 for i, key in sorted(self.out_data.items()): if isinstance(i, int): continue if i != self.active_key: items[j] = key j += 1 # update internal parameters self.out_data = items if self.imain >= self.active_key: self.imain = max(0, self.imain - 1) self.active_key = max(0, self.active_key - 1) self.nrows -= 1 self.keys = [group.name for key, group in sorted(items.items())] self.recreate_table() # update key name = self.keys[self.active_key] self._update_active_key_by_name(name) def on_set_as_main(self): bold = QtGui.QFont() bold.setBold(True) bold.setItalic(True) normal = QtGui.QFont() normal.setBold(False) normal.setItalic(False) obj = self.table.item(self.imain) obj.setFont(normal) self.imain = self.active_key obj = self.table.item(self.imain) obj.setFont(bold) group = self.out_data[self.imain] self._default_elements = group.element_str self._default_name = group.name self.on_update_main() def on_update_main(self): """adds/removes the elements to the main actor when add/remove is pressed""" group = self.out_data[self.imain] if self._default_name == group.name and self.win_parent is not None: # we're not testing the menu self.win_parent.post_group(group, update_groups=True) def closeEvent(self, event): """closes the window""" self.remove_highlight_actor() self.out_data['close'] = True event.accept() def remove_highlight_actor(self): """removes the highlighted actor""" gui = self.win_parent remove_actors_from_gui(gui, self.actors, render=True) self.actors = [] def on_highlight(self, nids=None, eids=None): """highlights the nodes""" gui = self.win_parent unused_name = self.keys[self.active_key] if gui is not None: self.remove_highlight_actor() ## TODO: super strange; doesn't work... mouse_actions = gui.mouse_actions grid = mouse_actions.get_grid_selected(self.model_name) #all_nodes = mouse_actions.node_ids all_elements = mouse_actions.element_ids actors = create_highlighted_actors(gui, grid, all_nodes=None, nodes=nids, all_elements=all_elements, elements=eids, add_actors=False) if actors: add_actors_to_gui(gui, actors, render=True) self.actors = actors def on_highlight_elements(self): """highlights the active elements""" self.on_highlight(eids=self.eids) def on_highlight_add(self): """highlights the elements to add""" eids, is_valid = check_patran_syntax(self.add_edit, pound=self.elements_pound) if not is_valid: #self.add_edit.setStyleSheet("QLineEdit{background: red;}") return self.on_highlight(eids=eids) def on_highlight_remove(self): """highlights the elements to remove""" eids, is_valid = check_patran_syntax(self.remove_edit) if not is_valid: #self.remove_edit.setStyleSheet("QLineEdit{background: red;}") return self.on_highlight(eids=eids) def on_add(self): self.remove_highlight_actor() eids, is_valid = check_patran_syntax(self.add_edit, pound=self.elements_pound) #adict, is_valid = check_patran_syntax_dict(self.add_edit) if not is_valid: #self.add_edit.setStyleSheet("QLineEdit{background: red;}") return self.eids = unique(hstack([self.eids, eids])) #self.eids = _add(adict, ['e', 'elem', 'element'], self.eids) #self.cids = _add(adict, ['c', 'cid', 'coord'], self.cids) self._apply_cids_eids() self.add_edit.clear() self.add_edit.setStyleSheet("QLineEdit{background: white;}") self.on_update_main() def _apply_cids_eids(self): #ctext = _get_collapsed_text(self.cids) etext = _get_collapsed_text(self.eids) #self.coords_edit.setText(str(ctext.lstrip())) self.elements_edit.setText(str(etext.lstrip())) self.out_data[self.active_key].element_ids = self.eids def on_remove(self): self.remove_highlight_actor() eids, is_valid = check_patran_syntax(self.remove_edit) #adict, is_valid = check_patran_syntax_dict(self.remove_edit) if not is_valid: #self.remove_edit.setStyleSheet("QLineEdit{background: red;}") return #self.eids = _remove(adict, ['e', 'elem', 'element'], self.eids) #self.cids = _remove(adict, ['c', 'cid', 'coord'], self.cids) self.eids = setdiff1d(self.eids, eids) self._apply_cids_eids() self.remove_edit.clear() self.remove_edit.setStyleSheet(QLINE_EDIT_BASIC) self.on_update_main() def on_default_name(self): self.remove_highlight_actor() name = str(self._default_name) self.name_edit.setText(name) self.name_edit.setStyleSheet("QLineEdit{background: white;}") def on_default_elements(self): self.remove_highlight_actor() element_str = str(self._default_elements) self.elements_edit.setText(element_str) self.elements_edit.setStyleSheet("QLineEdit{background: white;}") group = self.out_data[self.active_key] group.element_str = element_str def check_name(self, cell): cell_value = cell.text() try: text = str(cell_value).strip() except UnicodeEncodeError: cell.setStyleSheet("QLineEdit{background: red;}") return None, False if len(text): cell.setStyleSheet("QLineEdit{background: white;}") return text, True else: cell.setStyleSheet("QLineEdit{background: red;}") return None, False if self._default_name != text: if self._default_name in self.out_data: cell.setStyleSheet("QLineEdit{background: white;}") return text, True else: cell.setStyleSheet("QLineEdit{background: red;}") return None, False def on_validate(self): name, flag0 = self.check_name(self.name_edit) unused_elements, flag1 = check_patran_syntax(self.elements_edit, pound=self.elements_pound) #coords_value, flag2 = check_patran_syntax( #self.coords_edit, pound=self.coords_pound) if all([flag0, flag1]): self._default_name = name self._default_elements = self.eids self.out_data['clicked_ok'] = True self.out_data['close'] = True return True return False def on_apply(self, force=False): passed = self.on_validate() if passed or force: self.win_parent._apply_modify_groups(self.out_data) return passed def on_ok(self): passed = self.on_apply() if passed: self.close() #self.destroy() def on_cancel(self): self.remove_highlight_actor() self.out_data['close'] = True self.close() def on_update_active_key(self, index): self.update_active_key(index) #str(index.text()) def update_active_key(self, index): #old_obj = self.out_data[self.imain] name = str(index.text()) self._update_active_key_by_name(name) def _update_active_key_by_name(self, name): if name in self.keys: self.active_key = self.keys.index(name) else: # we (hopefully) just removed a row #self.active_key = self.keys[self.active_key] pass self.name_edit.setText(name) obj = self.out_data[self.active_key] self.eids = parse_patran_syntax(obj.element_str, pound=obj.elements_pound) self._default_elements = obj.element_str self._default_name = name self._apply_cids_eids() self.set_as_main_button.setEnabled(True) if name in ['main', 'anti-main']: enabled = False self.elements_edit.setEnabled(False) if name == 'anti-main': self.set_as_main_button.setEnabled(False) #self.apply_button.setEnabled(False) #self.ok_button.setEnabled(False) else: enabled = True self.elements_highlight_button.setEnabled(True) self.add_label.setEnabled(True) self.add_highlight_button.setEnabled(True) self.remove_highlight_button.setEnabled(True) #self.apply_button.setEnabled(True) #self.ok_button.setEnabled(True) self.name_label.setEnabled(enabled) self.name_set.setEnabled(enabled) self.name_edit.setEnabled(enabled) self.name_button.setEnabled(enabled) self.elements_label.setEnabled(enabled) self.elements_button.setEnabled(enabled) self.add_button.setEnabled(enabled) self.add_edit.setEnabled(enabled) self.remove_label.setEnabled(enabled) self.remove_button.setEnabled(enabled) self.remove_edit.setEnabled(enabled) self.delete_group_button.setEnabled(enabled)