def testReferenceCounting(self): '''Tests reference count of model object referred by view objects.''' model1 = TestModel() refcount1 = getrefcount(model1) view1 = QTableView() view1.setModel(model1) self.assertEqual(getrefcount(view1.model()), refcount1 + 1) view2 = QTableView() view2.setModel(model1) self.assertEqual(getrefcount(view2.model()), refcount1 + 2) model2 = TestModel() view2.setModel(model2) self.assertEqual(getrefcount(view1.model()), refcount1 + 1)
def testReferreedObjectSurvivalAfterContextEnd(self): '''Model object assigned to a view object must survive after getting out of context.''' def createModelAndSetToView(view): model = TestModel() model.setObjectName('created model') view.setModel(model) view = QTableView() createModelAndSetToView(view) model = view.model()
def testReferenceCountingWhenDeletingReferrer(self): '''Tests reference count of model object referred by deceased view object.''' model = TestModel() refcount1 = getrefcount(model) view = QTableView() view.setModel(model) self.assertEqual(getrefcount(view.model()), refcount1 + 1) del view self.assertEqual(getrefcount(model), refcount1)
class skillsWindow(QDialog): def __init__(self, dataModel, oberTablo): QDialog.__init__(self) self.setWindowTitle('All Skills') self.setWindowIcon(QIcon('elance.ico')) self.oberTablo = oberTablo #create & configure tablewiew self.table_view = QTableView() self.table_view.setModel(dataModel) self.table_view.setSortingEnabled(True) self.table_view.sortByColumn(1, Qt.DescendingOrder) self.table_view.resizeColumnsToContents() self.table_view.resizeRowsToContents() #http://stackoverflow.com/questions/7189305/set-optimal-size-of-a-dialog-window-containing-a-tablewidget #http://stackoverflow.com/questions/8766633/how-to-determine-the-correct-size-of-a-qtablewidget w = 0 w += self.table_view.contentsMargins().left() +\ self.table_view.contentsMargins().right() +\ self.table_view.verticalHeader().width() w += qApp.style().pixelMetric(QStyle.PM_ScrollBarExtent) for i in range(len(self.table_view.model().header)): w += self.table_view.columnWidth(i) self.table_view.horizontalHeader().setStretchLastSection(True) self.table_view.setMinimumWidth(w) # create two buttons self.findEntries = QPushButton('Find entries') self.findEntries.clicked.connect(self.ApplyFilterToMainList) self.cancel = QPushButton('Cancel') self.cancel.clicked.connect(self.winClose) self.mainLayout = QGridLayout() self.mainLayout.addWidget(self.table_view, 0,0,1,3) self.mainLayout.addWidget(self.findEntries, 1,0) self.mainLayout.addWidget(self.cancel, 1,2) self.setLayout(self.mainLayout) self.show() def ApplyFilterToMainList(self): selection = self.table_view.selectionModel().selection() skills = [] for selRange in selection: for index in selRange.indexes(): skill = index.model().data(index, Qt.DisplayRole) skills.append(skill) self.oberTablo.model().emit(SIGNAL("modelAboutToBeReset()")) self.oberTablo.model().criteria = {'Skills':skills} self.oberTablo.model().emit(SIGNAL("modelReset()")) self.close() def winClose(self): self.close()
class RunnerDialog(QDialog): options_added = Signal(Options) options_running = Signal(Options) options_simulated = Signal(Options) options_error = Signal(Options, Exception) results_saved = Signal(Results, str) results_error = Signal(Results, Exception) def __init__(self, parent=None): QDialog.__init__(self, parent) self.setWindowTitle('Runner') self.setMinimumWidth(750) # Runner self._runner = None self._running_timer = QTimer() self._running_timer.setInterval(500) # Widgets self._dlg_progress = QProgressDialog() self._dlg_progress.setRange(0, 100) self._dlg_progress.setModal(True) self._dlg_progress.hide() lbl_outputdir = QLabel("Output directory") self._txt_outputdir = DirBrowseWidget() max_workers = cpu_count() #@UndefinedVariable lbl_workers = QLabel('Number of workers') self._spn_workers = QSpinBox() self._spn_workers.setRange(1, max_workers) self._spn_workers.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) lbl_max_workers = QLabel('(max: %i)' % max_workers) self._chk_overwrite = QCheckBox("Overwrite existing results in output directory") self._chk_overwrite.setChecked(True) self._lbl_available = QLabel('Available') self._lst_available = QListView() self._lst_available.setModel(_AvailableOptionsListModel()) self._lst_available.setSelectionMode(QListView.SelectionMode.MultiSelection) tlb_available = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) tlb_available.addWidget(spacer) act_open = tlb_available.addAction(getIcon("document-open"), "Open") act_open.setShortcut(QKeySequence.Open) tlb_available.addSeparator() act_remove = tlb_available.addAction(getIcon("list-remove"), "Remove") act_clear = tlb_available.addAction(getIcon("edit-clear"), "Clear") self._btn_addtoqueue = QPushButton(getIcon("go-next"), "") self._btn_addtoqueue.setToolTip("Add to queue") self._btn_addtoqueue.setEnabled(False) self._btn_addalltoqueue = QPushButton(getIcon("go-last"), "") self._btn_addalltoqueue.setToolTip("Add all to queue") self._btn_addalltoqueue.setEnabled(False) self._lbl_options = QLabel('Queued/Running/Completed') self._tbl_options = QTableView() self._tbl_options.setModel(_StateOptionsTableModel()) self._tbl_options.setItemDelegate(_StateOptionsItemDelegate()) self._tbl_options.setSelectionMode(QListView.SelectionMode.NoSelection) self._tbl_options.setColumnWidth(1, 60) self._tbl_options.setColumnWidth(2, 80) header = self._tbl_options.horizontalHeader() header.setResizeMode(0, QHeaderView.Interactive) header.setResizeMode(1, QHeaderView.Fixed) header.setResizeMode(2, QHeaderView.Fixed) header.setResizeMode(3, QHeaderView.Stretch) self._btn_start = QPushButton(getIcon("media-playback-start"), "Start") self._btn_cancel = QPushButton("Cancel") self._btn_cancel.setEnabled(False) self._btn_close = QPushButton("Close") self._btn_import = QPushButton("Import") self._btn_import.setEnabled(False) # Layouts layout = QVBoxLayout() sublayout = QGridLayout() sublayout.addWidget(lbl_outputdir, 0, 0) sublayout.addWidget(self._txt_outputdir, 0, 1) sublayout.addWidget(lbl_workers, 1, 0) subsublayout = QHBoxLayout() subsublayout.addWidget(self._spn_workers) subsublayout.addWidget(lbl_max_workers) sublayout.addLayout(subsublayout, 1, 1) layout.addLayout(sublayout) sublayout.addWidget(self._chk_overwrite, 2, 0, 1, 3) sublayout = QGridLayout() sublayout.setColumnStretch(0, 1) sublayout.setColumnStretch(2, 3) sublayout.addWidget(self._lbl_available, 0, 0) sublayout.addWidget(self._lst_available, 1, 0) sublayout.addWidget(tlb_available, 2, 0) subsublayout = QVBoxLayout() subsublayout.addStretch() subsublayout.addWidget(self._btn_addtoqueue) subsublayout.addWidget(self._btn_addalltoqueue) subsublayout.addStretch() sublayout.addLayout(subsublayout, 1, 1) sublayout.addWidget(self._lbl_options, 0, 2) sublayout.addWidget(self._tbl_options, 1, 2) layout.addLayout(sublayout) sublayout = QHBoxLayout() sublayout.addStretch() sublayout.addWidget(self._btn_import) sublayout.addWidget(self._btn_start) sublayout.addWidget(self._btn_cancel) sublayout.addWidget(self._btn_close) layout.addLayout(sublayout) self.setLayout(layout) # Signal self._running_timer.timeout.connect(self._onRunningTimer) act_open.triggered.connect(self._onOpen) act_remove.triggered.connect(self._onRemove) act_clear.triggered.connect(self._onClear) self._btn_addtoqueue.released.connect(self._onAddToQueue) self._btn_addalltoqueue.released.connect(self._onAddAllToQueue) self._btn_start.released.connect(self._onStart) self._btn_cancel.released.connect(self._onCancel) self._btn_close.released.connect(self._onClose) self._btn_import.released.connect(self._onImport) self.options_added.connect(self._onOptionsAdded) self.options_running.connect(self._onOptionsRunning) self.options_simulated.connect(self._onOptionsSimulated) self.options_error.connect(self._onOptionsError) self.results_error.connect(self._onResultsError) # Defaults settings = get_settings() section = settings.add_section('gui') if hasattr(section, 'outputdir'): self._txt_outputdir.setPath(section.outputdir) if hasattr(section, 'maxworkers'): self._spn_workers.setValue(int(section.maxworkers)) if hasattr(section, 'overwrite'): state = True if section.overwrite.lower() == 'true' else False self._chk_overwrite.setChecked(state) def _onDialogProgressProgress(self, progress, status): self._dlg_progress.setValue(progress * 100) self._dlg_progress.setLabelText(status) def _onDialogProgressCancel(self): self._dlg_progress.hide() if self._options_reader_thread is None: return self._options_reader_thread.cancel() self._options_reader_thread.quit() self._options_reader_thread.wait() def _onDialogProgressException(self, ex): self._dlg_progress.hide() self._options_reader_thread.quit() self._options_reader_thread.wait() messagebox.exception(self, ex) def _onRunningTimer(self): self._tbl_options.model().reset() def _onOpen(self): settings = get_settings() curdir = getattr(settings.gui, 'opendir', os.getcwd()) filepath, namefilter = \ QFileDialog.getOpenFileName(self, "Open", curdir, 'Options [*.xml] (*.xml)') if not filepath or not namefilter: return settings.gui.opendir = os.path.dirname(filepath) if not filepath.endswith('.xml'): filepath += '.xml' self._options_reader_thread = _OptionsReaderWrapperThread(filepath) self._dlg_progress.canceled.connect(self._onDialogProgressCancel) self._options_reader_thread.resultReady.connect(self._onOpened) self._options_reader_thread.progressUpdated.connect(self._onDialogProgressProgress) self._options_reader_thread.exceptionRaised.connect(self._onDialogProgressException) self._options_reader_thread.start() self._dlg_progress.reset() self._dlg_progress.show() def _onOpened(self, options): self._dlg_progress.hide() self._options_reader_thread.quit() self._options_reader_thread.wait() self._options_reader_thread = None try: self._lst_available.model().addOptions(options) except Exception as ex: messagebox.exception(self, ex) def _onRemove(self): selection = self._lst_available.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Queue", "Select an options") return model = self._lst_available.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): model.popOptions(row) def _onClear(self): self._lst_available.model().clearOptions() def _onAddToQueue(self): selection = self._lst_available.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Queue", "Select an options") return model = self._lst_available.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): options = model.options(row) try: self._runner.put(options) except Exception as ex: messagebox.exception(self, ex) return def _onAddAllToQueue(self): model = self._lst_available.model() for row in reversed(range(0, model.rowCount())): options = model.options(row) try: self._runner.put(options) except Exception as ex: messagebox.exception(self, ex) return def _onStart(self): outputdir = self._txt_outputdir.path() if not outputdir: QMessageBox.critical(self, 'Start', 'Missing output directory') return max_workers = self._spn_workers.value() overwrite = self._chk_overwrite.isChecked() self.start(outputdir, overwrite, max_workers) def _onCancel(self): self.cancel() def _onClose(self): if self._runner is not None: self._runner.close() self._running_timer.stop() self.close() def _onImport(self): list_options = self._lst_available.model().listOptions() if not list_options: return # Select options dialog = _OptionsSelector(list_options) if not dialog.exec_(): return options = dialog.options() # Start importer outputdir = self._runner.outputdir max_workers = self._runner.max_workers importer = LocalImporter(outputdir, max_workers) importer.start() importer.put(options) self._dlg_progress.show() try: while importer.is_alive(): if self._dlg_progress.wasCanceled(): importer.cancel() break self._dlg_progress.setValue(importer.progress * 100) finally: self._dlg_progress.hide() def _onOptionsAdded(self, options): logging.debug('runner: optionsAdded') self._tbl_options.model().addOptions(options) def _onOptionsRunning(self, options): logging.debug('runner: optionsRunning') self._tbl_options.model().resetOptions(options) def _onOptionsSimulated(self, options): logging.debug('runner: optionsSimulated') self._tbl_options.model().resetOptions(options) def _onOptionsError(self, options, ex): logging.debug('runner: optionsError') self._tbl_options.model().resetOptions(options) def _onResultsError(self, results, ex): logging.debug('runner: resultsError') self._tbl_options.model().reset() def closeEvent(self, event): if self.is_running(): message = 'Runner is running. Do you want to continue?' answer = QMessageBox.question(self, 'Runner', message, QMessageBox.Yes | QMessageBox.No) if answer == QMessageBox.No: event.ignore() return self.cancel() self._dlg_progress.close() settings = get_settings() section = settings.add_section('gui') path = self._txt_outputdir.path() if path: section.outputdir = path section.maxworkers = str(self._spn_workers.value()) section.overwrite = str(self._chk_overwrite.isChecked()) settings.write() event.accept() def addAvailableOptions(self, options): self._lst_available.model().addOptions(options) def removeAvailableOptions(self, options): self._lst_available.model().removeOptions(options) def clearAvailableOptions(self): self._lbl_available.model().clearOptions() def start(self, outputdir, overwrite, max_workers): self._runner = LocalRunner(outputdir=outputdir, overwrite=overwrite, max_workers=max_workers) self._tbl_options.setModel(_StateOptionsTableModel(self._runner)) self._spn_workers.setEnabled(False) self._txt_outputdir.setEnabled(False) self._chk_overwrite.setEnabled(False) self._btn_addtoqueue.setEnabled(True) self._btn_addalltoqueue.setEnabled(True) self._btn_start.setEnabled(False) self._btn_cancel.setEnabled(True) self._btn_close.setEnabled(False) self._btn_import.setEnabled(True) self._runner.options_added.connect(self.options_added.emit) self._runner.options_running.connect(self.options_running.emit) self._runner.options_simulated.connect(self.options_simulated.emit) self._runner.options_error.connect(self.options_error.emit) self._runner.results_saved.connect(self.results_saved.emit) self._runner.results_error.connect(self.results_error.emit) self._running_timer.start() self._runner.start() def cancel(self): if self._runner is None: return self._runner.cancel() self._running_timer.stop() self._runner.options_added.disconnect(self.options_added.emit) self._runner.options_running.disconnect(self.options_running.emit) self._runner.options_simulated.disconnect(self.options_simulated.emit) self._runner.options_error.disconnect(self.options_error.emit) self._runner.results_saved.disconnect(self.results_saved.emit) self._runner.results_error.disconnect(self.results_error.emit) self._runner = None self._spn_workers.setEnabled(True) self._txt_outputdir.setEnabled(True) self._chk_overwrite.setEnabled(True) self._btn_addtoqueue.setEnabled(False) self._btn_addalltoqueue.setEnabled(False) self._btn_start.setEnabled(True) self._btn_cancel.setEnabled(False) self._btn_close.setEnabled(True) self._btn_import.setEnabled(False) def is_running(self): return self._runner is not None and self._runner.is_alive()
def copy_table_view_to_csv(self, view: QTableView, special_headers=[], special_formatters=dict()): """ Copies the selected rows in the view to the clipboard Will use the Horse delegates if any (because they display information in a different way). :param view: :return: """ rows_ndx = self._selected_rows(view.selectedIndexes()) model = view.model() visible_cols = [] for c in range(model.columnCount()): if not view.isColumnHidden(c): visible_cols.append(c) s = "" if special_headers: h = special_headers else: h = [] mh = view.horizontalHeader().model() for col in visible_cols: h.append(mh.headerData(col, Qt.Horizontal, Qt.DisplayRole)) s += self._line_to_csv(h) for row in rows_ndx: r = [] for col in visible_cols: model_index = model.index(row, col) if col in special_formatters: formatted = special_formatters[col](model_index) if type(formatted) in (list, tuple): r += list(formatted) elif type(formatted) == float: r.append(format_csv(formatted)) else: r.append(str(formatted)) else: d = view.itemDelegateForColumn(col) if d: displayed_data = d.get_displayed_data(model_index) else: displayed_data = model_index.data(Qt.DisplayRole) if displayed_data and type(model_index.data( Qt.UserRole)) == float: # FIXME This a hack to convert float representations to # the convert decimal format for CSV pasting. Rmemeber that MS Excel # might have different decimal point, based on the locale... # This is sub optimal because a float might not always be represented # as a float... But it's not the case for now => not a problem. r.append(displayed_data.replace(u".", decimal_point)) else: r.append(displayed_data) s += self._line_to_csv(r) mainlog.debug("copy_table_view: {}".format(s)) QApplication.clipboard().setText(s)
class PhotonIntensityResultWidget(_SaveableResultWidget): def _initUI(self): # Variables model = _PhotonIntensityResultTableModel(self.result()) # Widgets self._table = QTableView() self._table.setModel(model) header = self._table.horizontalHeader() for i in range(1, 9): header.setResizeMode(i, QHeaderView.Stretch) # Layouts layout = _SaveableResultWidget._initUI(self) layout.addWidget(self._table) return layout def _initToolbox(self): toolbox = _SaveableResultWidget._initToolbox(self) self._itm_abbrev = _PhotonIntensityResultAbbreviationToolItem(self) toolbox.addItem(self._itm_abbrev, "Abbreviations") itm_detector = DetectorToolItem(self) toolbox.addItem(itm_detector, "Detector") self._itm_options = _PhotonIntensityResultOptionsToolItem(self) self._itm_options.stateChanged.connect(self._onOptionsChanged) toolbox.addItem(self._itm_options, "Options") return toolbox def _onOptionsChanged(self): model = self._table.model() model.setShowUncertainty(self._itm_options.showUncertainty()) pg, cg, bg, tg = self._itm_options.showGenerated() pe, ce, be, te = self._itm_options.showEmitted() self._table.setColumnHidden(1, not pg) self._table.setColumnHidden(2, not pe) self._table.setColumnHidden(3, not cg) self._table.setColumnHidden(4, not ce) self._table.setColumnHidden(5, not bg) self._table.setColumnHidden(6, not be) self._table.setColumnHidden(7, not tg) self._table.setColumnHidden(8, not te) factor = self._itm_options.factor() model.setFactor(factor) def dump(self): rows = [] rows.append( [ "Transition", "PG", "PG unc", "PE", "PE unc", "CG", "CG unc", "CE", "CE unc", "BG", "BG unc", "BE", "BE unc", "TG", "TG unc", "TE", "TE unc", ] ) result = self.result() for transition in result: row = [transition] row.extend(result.intensity(transition, False, False)) row.extend(result.intensity(transition, True, False)) row.extend(result.characteristic_fluorescence(transition, False)) row.extend(result.characteristic_fluorescence(transition, True)) row.extend(result.bremsstrahlung_fluorescence(transition, False)) row.extend(result.bremsstrahlung_fluorescence(transition, True)) row.extend(result.intensity(transition, False, True)) row.extend(result.intensity(transition, True, True)) rows.append(row) return rows
class MainWindow(QMainWindow): def __init__(self, datta): QMainWindow.__init__(self) self.setWindowTitle('Project Parser') appIcon = QIcon('search.png') self.setWindowIcon(appIcon) self.viewPortBL = QDesktopWidget().availableGeometry().topLeft() self.viewPortTR = QDesktopWidget().availableGeometry().bottomRight() self.margin = int(QDesktopWidget().availableGeometry().width()*0.1/2) self.shirina = QDesktopWidget().availableGeometry().width() - self.margin*2 self.visota = QDesktopWidget().availableGeometry().height() - self.margin*2 self.setGeometry(self.viewPortBL.x() + self.margin, self.viewPortBL.y() + self.margin, self.shirina, self.visota) # statusbar self.myStatusBar = QStatusBar() self.setStatusBar(self.myStatusBar) #lower long layout self.lowerLong = QFrame() self.detailsLabel = QLabel() self.skillsLabel = QLabel() self.urlLabel = QLabel() self.locationLabel = QLabel() self.skillsLabel.setText('skills') self.detailsLabel.setWordWrap(True) self.la = QVBoxLayout() self.la.addWidget(self.detailsLabel) self.la.addWidget(self.skillsLabel) self.la.addWidget(self.urlLabel) self.la.addWidget(self.locationLabel) self.lowerLong.setLayout(self.la) # table self.source_model = MyTableModel(self, datta, ['Id', 'Date', 'Title']) self.proxy_model = myTableProxy(self) self.proxy_model.setSourceModel(self.source_model) self.proxy_model.setDynamicSortFilter(True) self.table_view = QTableView() self.table_view.setModel(self.proxy_model) self.table_view.setAlternatingRowColors(True) self.table_view.resizeColumnsToContents() self.table_view.resizeRowsToContents() self.table_view.horizontalHeader().setStretchLastSection(True) self.table_view.setSortingEnabled(True) self.table_view.sortByColumn(2, Qt.AscendingOrder) # events self.selection = self.table_view.selectionModel() self.selection.selectionChanged.connect(self.handleSelectionChanged) #DO NOT use CreateIndex() method, use index() index = self.proxy_model.index(0,0) self.selection.select(index, QItemSelectionModel.Select) self.upperLong = self.table_view # right side widgets self.right = QFrame() self.la1 = QVBoxLayout() self.btnDownload = QPushButton('Download data') self.btnDownload.clicked.connect(self.download) self.myButton = QPushButton('Show Skillls') self.myButton.clicked.connect(self.showAllSkills) self.btnSearchByWord = QPushButton('Search by word(s)') self.btnSearchByWord.clicked.connect(self.onSearchByWord) self.btnResetFilter= QPushButton('Discard Filter') self.btnResetFilter.clicked.connect(self.discardFilter) self.btnCopyURL = QPushButton('URL to Clipboard') self.btnCopyURL.clicked.connect(self.copyToClipboard) self.btnExit = QPushButton('Exit') self.btnExit.clicked.connect(lambda: sys.exit()) self.dateTimeStamp = QLabel() self.la1.addWidget(self.btnDownload) self.la1.addSpacing(10) self.la1.addWidget(self.myButton) self.la1.addSpacing(10) self.la1.addWidget(self.btnSearchByWord) self.la1.addSpacing(10) self.la1.addWidget(self.btnResetFilter) self.la1.addSpacing(10) self.la1.addWidget(self.btnCopyURL) self.la1.addSpacing(70) self.la1.addWidget(self.btnExit) self.la1.addStretch(stretch=0) self.la1.addWidget(self.dateTimeStamp) self.right.setLayout(self.la1) self.right.setFrameShape(QFrame.StyledPanel) # splitters self.horiSplit = QSplitter(Qt.Vertical) self.horiSplit.addWidget(self.upperLong) self.horiSplit.addWidget(self.lowerLong) self.horiSplit.setSizes([self.visota/2, self.visota/2]) self.vertiSplit = QSplitter(Qt.Horizontal) self.vertiSplit.addWidget(self.horiSplit) self.vertiSplit.addWidget(self.right) self.vertiSplit.setSizes([self.shirina*3/4, self.shirina*1/4]) self.setCentralWidget(self.vertiSplit) self.settings = QSettings('elance.ini', QSettings.IniFormat) self.settings.beginGroup('DATE_STAMP') self.dateTimeStamp.setText('Data actuality: %s' % self.settings.value('date/time')) self.settings.endGroup() self.statusText = '' def handleSelectionChanged(self, selected, deselected): for index in selected.first().indexes(): #print('Row %d is selected' % index.row()) ind = index.model().mapToSource(index) desc = ind.model().mylist[ind.row()]['Description'] self.detailsLabel.setText(desc) skills = ', '.join(ind.model().mylist[ind.row()]['Skills']).strip() self.skillsLabel.setText(skills) url = ind.model().mylist[ind.row()]['URL'] self.urlLabel.setText(url) location = ind.model().mylist[ind.row()]['Location'] self.locationLabel.setText(location) def showAllSkills(self): listSkills = [] for elem in self.source_model.mylist: listSkills += elem['Skills'] allSkills = Counter(listSkills) tbl = MyTableModel(self, allSkills.items(), ['Skill', 'Freq']) win = skillsWindow(tbl, self.table_view) win.exec_() def discardFilter(self): self.table_view.model().emit(SIGNAL("modelAboutToBeReset()")) self.table_view.model().criteria = {} self.table_view.model().emit(SIGNAL("modelReset()")) self.table_view.resizeRowsToContents() def download(self): self.btnDownload.setDisabled(True) self.statusLabel = QLabel('Connecting') self.progressBar = QProgressBar() self.progressBar.setMinimum(0) self.progressBar.setMaximum(100) self.myStatusBar.addWidget(self.statusLabel, 2) self.myStatusBar.addWidget(self.progressBar, 1) self.progressBar.setValue(1) self.settings.beginGroup('URLS') initialLink = self.settings.value('CategoriesDetailed/VahaSelected/InitialLink') pagingLink = self.settings.value('CategoriesDetailed/VahaSelected/PagingLink') self.settings.endGroup() downloader = Downloader(initialLink, pagingLink, 25, 5) downloader.messenger.downloadProgressChanged.connect(self.onDownloadProgressChanged) downloader.messenger.downloadComplete.connect(self.onDownloadComplete) downloader.download() def onDownloadComplete(self): #QMessageBox.information(self, 'Download complete', 'Download complete!', QMessageBox.Ok) self.table_view.model().emit(SIGNAL("modelAboutToBeReset()")) self.settings.beginGroup('DATE_STAMP') self.settings.setValue('date/time', time.strftime('%d-%b-%Y, %H:%M:%S')) self.dateTimeStamp.setText('Data actuality: %s' % self.settings.value('date/time')) self.settings.endGroup() with open("elance.json") as json_file: jobDB = json.load(json_file) for elem in jobDB: words = nltk.tokenize.regexp_tokenize(elem['Title'].lower(), r'\w+') elem['Tokens'] = words elem['Skills'] = [t.strip() for t in elem['Skills'].split(',')] self.source_model.mylist = jobDB self.table_view.model().emit(SIGNAL("modelReset()")) self.btnDownload.setEnabled(True) self.myStatusBar.removeWidget(self.statusLabel) self.myStatusBar.removeWidget(self.progressBar) self.myStatusBar.showMessage(self.statusText, timeout = 5000) def onDownloadProgressChanged(self, stata): self.progressBar.setValue(stata[2]) #text = 'Processed records{:5d} of{:5d}'.format(percentage[0], percentage[1]) bajtikov = '{:,}'.format(stata[5]) self.statusText = 'Processed page{:4d} of{:4d}. \ Job entries{:5d} of{:5d}. \ Downloaded{:>12s} Bytes'.format(stata[3], stata[4], stata[0], stata[1], bajtikov) self.statusLabel.setText(self.statusText) def copyToClipboard(self): clipboard = QApplication.clipboard() clipboard.setText(self.urlLabel.text()) self.myStatusBar.showMessage(self.urlLabel.text(), timeout = 3000) def onSearchByWord(self): text, ok = QInputDialog.getText(self, 'Search the base by word(s)', 'Enter your keyword/phrase to search for:') if ok: words = [t.strip() for t in nltk.tokenize.regexp_tokenize(text.lower(), r'\w+')] self.table_view.model().emit(SIGNAL("modelAboutToBeReset()")) self.table_view.model().criteria = {'Description' : words} self.table_view.model().emit(SIGNAL("modelReset()"))
def testModelWithParent(self): view = QTableView() model = TestModel(None) view.setModel(model) samemodel = view.model() self.assertEqual(model, samemodel)
class ModelTableWidget(QWidget): dataChanged = Signal(QModelIndex, QModelIndex) class _ModelTableModel(QAbstractTableModel): def __init__(self): QAbstractTableModel.__init__(self) self._models = [] def rowCount(self, *args, **kwargs): return len(self._models) def columnCount(self, *args, **kwargs): return 2 def data(self, index, role=Qt.DisplayRole): if not index.isValid() or not (0 <= index.row() < len(self._models)): return None if role == Qt.TextAlignmentRole: return Qt.AlignCenter model = self._models[index.row()] if model is None: return "" if role == Qt.DisplayRole or role == Qt.ToolTipRole: column = index.column() if column == 0: return str(model.type) elif column == 1: return str(model) return None def headerData(self, section, orientation, role): if role != Qt.DisplayRole: return None if orientation == Qt.Horizontal: if section == 0: return "Type" elif section == 1: return "Model" elif orientation == Qt.Vertical: return str(section + 1) def flags(self, index): if not index.isValid(): return Qt.ItemIsEnabled return Qt.ItemFlags(QAbstractTableModel.flags(self, index)) def setData(self, index, value, role=Qt.EditRole): if not index.isValid() or not (0 <= index.row() < len(self._models)): return False row = index.row() self._models[row] = value self.dataChanged.emit(index, index) return True def insertRows(self, row, count=1, parent=None): if parent is None: parent = QModelIndex() self.beginInsertRows(parent, row, row + count - 1) for _ in range(count): self._models.insert(row, None) self.endInsertRows() return True def removeRows(self, row, count=1, parent=None): if parent is None: parent = QModelIndex() self.beginRemoveRows(parent, row, row + count - 1) for index in reversed(range(row, row + count)): self._models.pop(index) self.endRemoveRows() return True def append(self, model): self.insert(self.rowCount(), model) def insert(self, index, model): self.insertRows(index) self.setData(self.createIndex(index, 0), model) def remove(self, model): index = self._models.index(model) self.removeRows(index) def clear(self): self.removeRows(0, self.rowCount()) def models(self): models = set(self._models) models.discard(None) return models def model(self, index): return self._models[index.row()] def __init__(self, parent=None): QWidget.__init__(self, parent) # Variables model = self._ModelTableModel() # Widgets self._tbl_models = QTableView() self._tbl_models.setModel(model) header = self._tbl_models.horizontalHeader() header.setResizeMode(QHeaderView.Stretch) policy = self._tbl_models.sizePolicy() policy.setVerticalStretch(True) self._tbl_models.setSizePolicy(policy) self._tbl_models.setSelectionMode(QTableView.SelectionMode.MultiSelection) # Layouts layout = QVBoxLayout() layout.addWidget(self._tbl_models) self.setLayout(layout) # Signals model.dataChanged.connect(self.dataChanged) def addModel(self, model): self._tbl_models.model().append(model) def addModels(self, models): for model in models: self.addModel(model) def removeModel(self, model): self._tbl_models.model().remove(model) def clear(self): self._tbl_models.model().clear() def models(self): return self._tbl_models.model().models() def currentModels(self): tbl_model = self._tbl_models.model() models = [] for index in self._tbl_models.selectionModel().selection().indexes(): models.append(tbl_model.model(index)) return models
class LayerListWidget(_ParameterWidget): def __init__(self, parameter, parent=None): _ParameterWidget.__init__(self, parameter, parent) # Variables model = _LayerModel() self._material_class = Material # Actions act_add = QAction(getIcon("list-add"), "Add layer", self) act_remove = QAction(getIcon("list-remove"), "Remove layer", self) act_clean = QAction(getIcon('edit-clear'), "Clear", self) # Widgets self._cb_unit = UnitComboBox('m') self._cb_unit.setUnit('um') self._tbl_layers = QTableView() self._tbl_layers.setModel(model) self._tbl_layers.setItemDelegate(_LayerDelegate()) header = self._tbl_layers.horizontalHeader() header.setResizeMode(QHeaderView.Stretch) header.setStyleSheet('color: blue') self._tlb_layers = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._tlb_layers.addWidget(spacer) self._tlb_layers.addAction(act_add) self._tlb_layers.addAction(act_remove) self._tlb_layers.addAction(act_clean) # Layouts layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) sublayout = QHBoxLayout() sublayout.addStretch() sublayout.addWidget(QLabel('Thickness unit')) sublayout.addWidget(self._cb_unit) layout.addLayout(sublayout) layout.addWidget(self._tbl_layers) layout.addWidget(self._tlb_layers) self.setLayout(layout) # Signals self.valuesChanged.connect(self._onChanged) self.validationRequested.connect(self._onChanged) act_add.triggered.connect(self._onAdd) act_remove.triggered.connect(self._onRemove) act_clean.triggered.connect(self._onClear) self._tbl_layers.doubleClicked.connect(self._onDoubleClicked) model.dataChanged.connect(self.valuesChanged) model.rowsInserted.connect(self.valuesChanged) model.rowsRemoved.connect(self.valuesChanged) self.validationRequested.emit() def _onChanged(self): if self.hasAcceptableInput(): self._tbl_layers.setStyleSheet("background: none") else: self._tbl_layers.setStyleSheet("background: pink") def _onDoubleClicked(self, index): if index.column() != 0: return model = self._tbl_layers.model() materials = model.materials(index) if len(materials) == 0: dialog = get_material_dialog_class(self._material_class)() elif len(materials) == 1: dialog = get_material_dialog_class(self._material_class)() dialog.setValue(materials[0]) else: dialog = MaterialListDialog() dialog.setMaterialClass(self._material_class) dialog.setValues(materials) dialog.setReadOnly(self.isReadOnly()) if not dialog.exec_(): return model.setData(index, dialog.values()) def _onAdd(self): index = self._tbl_layers.selectionModel().currentIndex() model = self._tbl_layers.model() model.insertRows(index.row() + 1) # Show material dialog right away index = model.createIndex(index.row() + 1, 0) self._onDoubleClicked(index) def _onRemove(self): selection = self._tbl_layers.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Layer", "Select a row") return model = self._tbl_layers.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): model.removeRow(row) def _onClear(self): model = self._tbl_layers.model() for row in reversed(range(model.rowCount())): model.removeRow(row) def values(self): factor = self._cb_unit.factor() layers = [] for material, thickness in self._tbl_layers.model().layers(): if not material or not thickness: continue thickness_m = np.array(thickness, ndmin=1) * factor layers.append(_MockLayer(material, thickness_m)) return layers def setValues(self, layers): layers = np.array(layers, ndmin=1) factor = self._cb_unit.factor() model = self._tbl_layers.model() model.removeRows(0, model.rowCount()) model.insertRows(0, len(layers)) for i, layer in enumerate(layers): model.setData(model.index(i, 0), layer.material) model.setData(model.index(i, 1), layer.thickness_m / factor) def isReadOnly(self): return not self._cb_unit.isEnabled() and \ not self._tlb_layers.isVisible() def setReadOnly(self, state): self._cb_unit.setEnabled(not state) self._tlb_layers.setVisible(not state) style = 'color: none' if state else 'color: blue' self._tbl_layers.horizontalHeader().setStyleSheet(style) self._tbl_layers.itemDelegate().setReadOnly(state) def setMaterialClass(self, clasz): self._material_class = clasz
class DetectorWizardPage(_ExpandableOptionsWizardPage): class _DetectorComboBoxModel(QAbstractListModel): def __init__(self): QAbstractListModel.__init__(self) self._detectors = [] def rowCount(self, *args, **kwargs): return len(self._detectors) def data(self, index, role=Qt.DisplayRole): if not index.isValid() or \ not (0 <= index.row() < self.rowCount()): return None if role == Qt.TextAlignmentRole: return Qt.AlignCenter if role != Qt.DisplayRole: return None return self._detectors[index.row()]['text'] def setData(self, index, value, role=Qt.EditRole): if not index.isValid() or \ not (0 <= index.row() < len(self._detectors)): return False row = index.row() self._detectors[row] = value self.dataChanged.emit(index, index) return True def insertRows(self, row, count=1, parent=None): if count == 0: return False if parent is None: parent = QModelIndex() self.beginInsertRows(QModelIndex(), row, row + count - 1) for _ in range(count): value = {'text': '', 'class': None, 'widget_class': None} self._detectors.insert(row, value) self.endInsertRows() return True def removeRows(self, row, count=1, parent=None): if count == 0: return False if parent is None: parent = QModelIndex() self.beginRemoveRows(QModelIndex(), row, row + count - 1) for index in reversed(range(row, row + count)): self._detectors.pop(index) self.endRemoveRows() return True def append(self, text, clasz, widget_class): self.insert(self.rowCount(), text, clasz, widget_class) def insert(self, row, text, clasz, widget_class): self.insertRows(row) value = {'text': text, 'class': clasz, 'widget_class': widget_class} self.setData(self.createIndex(row, 0), value) def clear(self): self.removeRows(0, self.rowCount()) def widget_class(self, index): return self._detectors[index]['widget_class'] class _DetectorTableModel(QAbstractTableModel): def __init__(self): QAbstractTableModel.__init__(self) self._detectors = [] def rowCount(self, *args, **kwargs): return len(self._detectors) def columnCount(self, *args, **kwargs): return 2 def data(self, index, role=Qt.DisplayRole): if not index.isValid() or \ not (0 <= index.row() < len(self._detectors)): return None if role == Qt.TextAlignmentRole: return Qt.AlignCenter if role == Qt.DisplayRole or role == Qt.ToolTipRole: key, detector = self._detectors[index.row()] column = index.column() if column == 0: return key elif column == 1: return str(detector) if detector is not None else '' return None def headerData(self, section , orientation, role): if role != Qt.DisplayRole: return None if orientation == Qt.Horizontal: if section == 0: return 'Key' elif section == 1: return 'Detector' elif orientation == Qt.Vertical: return str(section + 1) def flags(self, index): if not index.isValid(): return Qt.ItemIsEnabled return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable) def setData(self, index, value, role=Qt.EditRole): if not index.isValid() or \ not (0 <= index.row() < len(self._detectors)): return False row = index.row() column = index.column() self._detectors[row][column] = value self.dataChanged.emit(index, index) return True def insertRows(self, row, count=1, parent=None): if count == 0: return False if parent is None: parent = QModelIndex() self.beginInsertRows(parent, row, row + count - 1) for _ in range(count): self._detectors.insert(row, ['untitled', None]) self.endInsertRows() return True def removeRows(self, row, count=1, parent=None): if count == 0: return False if parent is None: parent = QModelIndex() self.beginRemoveRows(parent, row, row + count - 1) for index in reversed(range(row, row + count)): self._detectors.pop(index) self.endRemoveRows() return True def append(self, key, detector): self.insert(self.rowCount(), key, detector) def insert(self, index, key, detector): self.insertRows(index) self.setData(self.createIndex(index, 0), key) self.setData(self.createIndex(index, 1), detector) def modify(self, index, key, detector): self.setData(self.createIndex(index, 0), key) self.setData(self.createIndex(index, 1), detector) def clear(self): self.removeRows(0, self.rowCount()) def detectors(self): detectors = {} for key, detector in self._detectors: if detector is not None: detectors.setdefault(key, []).append(detector) return detectors def detector(self, index): return self._detectors[index.row()][1] def key(self, index): return self._detectors[index.row()][0] class _DetectorTableDelegate(QItemDelegate): def __init__(self, parent=None): QItemDelegate.__init__(self, parent) def createEditor(self, parent, option, index): column = index.column() if column == 0: editor = QLineEdit(parent) editor.setValidator(QRegExpValidator(QRegExp(r"^(?!\s*$).+"))) return editor elif column == 1: return None def setEditorData(self, editor, index): column = index.column() if column == 0: key = index.model().data(index, Qt.DisplayRole) editor.setText(key) def setModelData(self, editor, model, index): column = index.column() if column == 0: if not editor.hasAcceptableInput(): return model.setData(index, editor.text()) def __init__(self, options, parent=None): _ExpandableOptionsWizardPage.__init__(self, options, parent) self.setTitle('Detector') def _initUI(self): # Variables self._widgets = {} tbl_model = self._DetectorTableModel() # Widgets self._cb_detector = QComboBox() self._cb_detector.setModel(self._DetectorComboBoxModel()) btn_detector_add = QPushButton() btn_detector_add.setIcon(getIcon("list-add")) self._tbl_detector = QTableView() self._tbl_detector.setModel(tbl_model) self._tbl_detector.setItemDelegate(self._DetectorTableDelegate()) header = self._tbl_detector.horizontalHeader() header.setResizeMode(1, QHeaderView.Stretch) policy = self._tbl_detector.sizePolicy() policy.setVerticalStretch(True) self._tbl_detector.setSizePolicy(policy) tlb_detector = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) tlb_detector.addWidget(spacer) act_remove = tlb_detector.addAction(getIcon("list-remove"), "Remove detector") act_clear = tlb_detector.addAction(getIcon("edit-clear"), "Clear") # Layouts layout = _ExpandableOptionsWizardPage._initUI(self) sublayout = QHBoxLayout() sublayout.addWidget(self._cb_detector, 1) sublayout.addWidget(btn_detector_add) layout.addRow("Select", sublayout) layout.addRow(self._tbl_detector) layout.addRow(tlb_detector) # Signals btn_detector_add.released.connect(self._onDetectorAdd) act_remove.triggered.connect(self._onDetectorRemove) act_clear.triggered.connect(self._onDetectorClear) self._tbl_detector.doubleClicked.connect(self._onDetectorDoubleClicked) tbl_model.dataChanged.connect(self.valueChanged) tbl_model.rowsInserted.connect(self.valueChanged) tbl_model.rowsRemoved.connect(self.valueChanged) return layout def _onDetectorAdd(self): index = self._tbl_detector.selectionModel().currentIndex() tbl_model = self._tbl_detector.model() cb_model = self._cb_detector.model() widget_class = cb_model.widget_class(self._cb_detector.currentIndex()) wdg_detector = widget_class() dialog = _DetectorDialog(wdg_detector) if not dialog.exec_(): return tbl_model.insert(index.row() + 1, dialog.key(), dialog.detector()) def _onDetectorRemove(self): selection = self._tbl_detector.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Detector", "Select a row") return tbl_model = self._tbl_detector.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): tbl_model.removeRow(row) def _onDetectorClear(self): model = self._tbl_detector.model() for row in reversed(range(model.rowCount())): model.removeRow(row) def _onDetectorDoubleClicked(self, index): if index.column() != 1: return tbl_model = self._tbl_detector.model() key = tbl_model.key(index) detector = tbl_model.detector(index) widget_class = self._widgets[detector.__class__] wdg_detector = widget_class() wdg_detector.setValue(detector) dialog = _DetectorDialog(wdg_detector, key) if not dialog.exec_(): return tbl_model.modify(index.row(), dialog.key(), dialog.detector()) def initializePage(self): _ExpandableOptionsWizardPage.initializePage(self) tbl_model = self._tbl_detector.model() cb_model = self._cb_detector.model() # Clear self._widgets.clear() tbl_model.clear() cb_model.clear() # Populate combo box it = self._iter_widgets('pymontecarlo.ui.gui.options.detector', 'DETECTORS') for clasz, widget_class, programs in it: widget = widget_class() self._widgets[clasz] = widget_class program_text = ', '.join(map(attrgetter('name'), programs)) text = '{0} ({1})'.format(widget.accessibleName(), program_text) cb_model.append(text, clasz, widget_class) del widget self._cb_detector.setCurrentIndex(0) # Add detector(s) for key, detectors in self.options().detectors.items(): detectors = np.array(detectors, ndmin=1) for detector in detectors: if not detector.__class__ in self._widgets: continue tbl_model.append(key, detector) def validatePage(self): tbl_model = self._tbl_detector.model() if tbl_model.rowCount() == 0: return False self.options().detectors.clear() self.options().detectors.update(tbl_model.detectors()) return True def expandCount(self): if self._tbl_detector.model().rowCount() == 0: return 0 try: count = 1 for detectors in self._tbl_detector.model().detectors().values(): count *= len(detectors) for detector in detectors: count *= len(expand(detector)) return count except: return 0
class PenelopeMaterialDialog(_MaterialDialog): def __init__(self, parent=None): _MaterialDialog.__init__(self, parent) self.setWindowTitle('Material') self.setMinimumWidth(1000) def _initUI(self): # Variables model_forcing = _InteractionForcingTableModel() # Actions act_add_forcing = QAction(getIcon("list-add"), "Add interaction forcing", self) act_remove_forcing = QAction(getIcon("list-remove"), "Remove interaction forcing", self) # Widgets self._lbl_elastic_scattering_c1 = QLabel('C1') self._lbl_elastic_scattering_c1.setStyleSheet("color: blue") self._txt_elastic_scattering_c1 = MultiNumericalLineEdit() self._txt_elastic_scattering_c1.setValidator(_ElasticScatteringValidator()) self._txt_elastic_scattering_c1.setValues([0.0]) self._lbl_elastic_scattering_c2 = QLabel('C2') self._lbl_elastic_scattering_c2.setStyleSheet("color: blue") self._txt_elastic_scattering_c2 = MultiNumericalLineEdit() self._txt_elastic_scattering_c2.setValidator(_ElasticScatteringValidator()) self._txt_elastic_scattering_c2.setValues([0.0]) self._lbl_cutoff_energy_inelastic = QLabel('Inelastic collisions') self._lbl_cutoff_energy_inelastic.setStyleSheet("color: blue") self._txt_cutoff_energy_inelastic = MultiNumericalLineEdit() self._txt_cutoff_energy_inelastic.setValidator(_CutoffEnergyValidator()) self._txt_cutoff_energy_inelastic.setValues([50.0]) self._cb_cutoff_energy_inelastic = UnitComboBox('eV') self._lbl_cutoff_energy_bremsstrahlung = QLabel('Bremsstrahlung emission') self._lbl_cutoff_energy_bremsstrahlung.setStyleSheet("color: blue") self._txt_cutoff_energy_bremsstrahlung = MultiNumericalLineEdit() self._txt_cutoff_energy_bremsstrahlung.setValidator(_CutoffEnergyValidator()) self._txt_cutoff_energy_bremsstrahlung.setValues([50.0]) self._cb_cutoff_energy_bremsstrahlung = UnitComboBox('eV') self._lbl_maximum_step_length = QLabel('Maximum step length') self._lbl_maximum_step_length.setStyleSheet("color: blue") self._txt_maximum_step_length = MultiNumericalLineEdit() self._txt_maximum_step_length.setValidator(_MaximumStepLengthValidator()) self._txt_maximum_step_length.setValues([1e15]) self._cb_maximum_step_length_unit = UnitComboBox('m') self._tbl_forcing = QTableView() self._tbl_forcing.setModel(model_forcing) self._tbl_forcing.setItemDelegate(_InteractionForcingDelegate()) header = self._tbl_forcing.horizontalHeader() header.setResizeMode(QHeaderView.Stretch) self._tlb_forcing = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self._tlb_forcing.addWidget(spacer) self._tlb_forcing.addAction(act_add_forcing) self._tlb_forcing.addAction(act_remove_forcing) # Layouts layout = QHBoxLayout() layout.addLayout(_MaterialDialog._initUI(self), 1) frame = QFrame() frame.setFrameShape(QFrame.VLine) frame.setFrameShadow(QFrame.Sunken) layout.addWidget(frame) sublayout = QVBoxLayout() box_elastic_scattering = QGroupBox("Elastic scattering") boxlayout = QFormLayout() boxlayout.addRow(self._lbl_elastic_scattering_c1, self._txt_elastic_scattering_c1) boxlayout.addRow(self._lbl_elastic_scattering_c2, self._txt_elastic_scattering_c2) box_elastic_scattering.setLayout(boxlayout) sublayout.addWidget(box_elastic_scattering) box_cutoff_energy = QGroupBox("Cutoff energy") boxlayout = QFormLayout() boxsublayout = QHBoxLayout() boxsublayout.addWidget(self._txt_cutoff_energy_inelastic, 1) boxsublayout.addWidget(self._cb_cutoff_energy_inelastic) boxlayout.addRow(self._lbl_cutoff_energy_inelastic, boxsublayout) boxsublayout = QHBoxLayout() boxsublayout.addWidget(self._txt_cutoff_energy_bremsstrahlung, 1) boxsublayout.addWidget(self._cb_cutoff_energy_bremsstrahlung) boxlayout.addRow(self._lbl_cutoff_energy_bremsstrahlung, boxsublayout) box_cutoff_energy.setLayout(boxlayout) sublayout.addWidget(box_cutoff_energy) subsublayout = QFormLayout() subsubsublayout = QHBoxLayout() subsubsublayout.addWidget(self._txt_maximum_step_length, 1) subsubsublayout.addWidget(self._cb_maximum_step_length_unit) subsublayout.addRow(self._lbl_maximum_step_length, subsubsublayout) sublayout.addLayout(subsublayout) box_forcing = QGroupBox('Interaction forcing') boxlayout = QVBoxLayout() boxlayout.addWidget(self._tbl_forcing) boxlayout.addWidget(self._tlb_forcing) box_forcing.setLayout(boxlayout) sublayout.addWidget(box_forcing) sublayout.addStretch() layout.addLayout(sublayout, 1) # Signals self._txt_elastic_scattering_c1.textChanged.connect(self._onElasticScatteringC1Changed) self._txt_elastic_scattering_c2.textChanged.connect(self._onElasticScatteringC2Changed) self._txt_cutoff_energy_inelastic.textChanged.connect(self._onCutoffEnergyInelasticChanged) self._txt_cutoff_energy_bremsstrahlung.textChanged.connect(self._onCutoffEnergyBremsstrahlungChanged) self._txt_maximum_step_length.textChanged.connect(self._onMaximumStepLengthChanged) act_add_forcing.triggered.connect(self._onForcingAdd) act_remove_forcing.triggered.connect(self._onForcingRemove) return layout def _onElasticScatteringC1Changed(self): if self._txt_elastic_scattering_c1.hasAcceptableInput(): self._txt_elastic_scattering_c1.setStyleSheet('background: none') else: self._txt_elastic_scattering_c1.setStyleSheet('background: pink') def _onElasticScatteringC2Changed(self): if self._txt_elastic_scattering_c2.hasAcceptableInput(): self._txt_elastic_scattering_c2.setStyleSheet('background: none') else: self._txt_elastic_scattering_c2.setStyleSheet('background: pink') def _onCutoffEnergyInelasticChanged(self): if self._txt_cutoff_energy_inelastic.hasAcceptableInput(): self._txt_cutoff_energy_inelastic.setStyleSheet('background: none') else: self._txt_cutoff_energy_inelastic.setStyleSheet('background: pink') def _onCutoffEnergyBremsstrahlungChanged(self): if self._txt_cutoff_energy_bremsstrahlung.hasAcceptableInput(): self._txt_cutoff_energy_bremsstrahlung.setStyleSheet('background: none') else: self._txt_cutoff_energy_bremsstrahlung.setStyleSheet('background: pink') def _onMaximumStepLengthChanged(self): if self._txt_maximum_step_length.hasAcceptableInput(): self._txt_maximum_step_length.setStyleSheet('background: none') else: self._txt_maximum_step_length.setStyleSheet('background: pink') def _onForcingAdd(self): index = self._tbl_forcing.selectionModel().currentIndex() model = self._tbl_forcing.model() model.insertRows(index.row() + 1) def _onForcingRemove(self): selection = self._tbl_forcing.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Interaction forcing", "Select a row") return model = self._tbl_forcing.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): model.removeRow(row) def _getParametersDict(self): params = _MaterialDialog._getParametersDict(self) params['c1'] = self._txt_elastic_scattering_c1.values().tolist() params['c2'] = self._txt_elastic_scattering_c2.values().tolist() wcc = self._txt_cutoff_energy_inelastic.values() * self._cb_cutoff_energy_inelastic.factor() params['wcc'] = wcc.tolist() wcr = self._txt_cutoff_energy_bremsstrahlung.values() * self._cb_cutoff_energy_bremsstrahlung.factor() params['wcr'] = wcr.tolist() dsmax = self._txt_maximum_step_length.values() * self._cb_maximum_step_length_unit.factor() params['dsmax'] = dsmax.tolist() params['forcings'] = \ self._tbl_forcing.model().interaction_forcings() return params def _generateName(self, parameters, varied): name = parameters.pop('name') if name is None: name = PenelopeMaterial.generate_name(parameters['composition']) parts = [name] for key in varied: if key == 'composition': continue elif key == 'forcings': forcing = parameters[key][0] forcer = forcing.forcer wlow = forcing.weight[0] whigh = forcing.weight[1] parts.append('forcings={0:n}_{1:n}_{2:n}'.format(forcer, wlow, whigh)) else: parts.append('{0:s}={1:n}'.format(key, parameters[key])) return '+'.join(parts) def _createMaterial(self, parameters, varied): mat = _MaterialDialog._createMaterial(self, parameters, varied) c1 = parameters['c1'] c2 = parameters['c2'] wcc = parameters['wcc'] wcr = parameters['wcr'] dsmax = parameters['dsmax'] forcings = parameters['forcings'] return PenelopeMaterial(mat.composition, mat.name, mat.density_kg_m3, mat.absorption_energy_eV, elastic_scattering=(c1, c2), cutoff_energy_inelastic_eV=wcc, cutoff_energy_bremsstrahlung_eV=wcr, interaction_forcings=forcings, maximum_step_length_m=dsmax) def setValue(self, material): _MaterialDialog.setValue(self, material) # Elastic scattering c1, c2 = material.elastic_scattering self._txt_elastic_scattering_c1.setValues(c1) self._txt_elastic_scattering_c2.setValues(c2) # Cutoff energy self._txt_cutoff_energy_inelastic.setValues(material.cutoff_energy_inelastic_eV) self._cb_cutoff_energy_inelastic.setUnit('eV') self._txt_cutoff_energy_bremsstrahlung.setValues(material.cutoff_energy_bremsstrahlung_eV) self._cb_cutoff_energy_bremsstrahlung.setUnit('eV') # Maximum step length self._txt_maximum_step_length.setValues(material.maximum_step_length_m) self._cb_maximum_step_length_unit.setUnit('m') # Interaction forcings forcings = material.interaction_forcings model = self._tbl_forcing.model() model.removeRows(0, model.rowCount()) model.insertRows(1, len(forcings)) for row, forcing in enumerate(forcings): model.setData(model.index(row, 0), forcing.particle) model.setData(model.index(row, 1), forcing.collision) model.setData(model.index(row, 2), forcing.forcer) model.setData(model.index(row, 3), forcing.weight[0]) model.setData(model.index(row, 4), forcing.weight[1]) def setReadOnly(self, state): _MaterialDialog.setReadOnly(self, state) style = 'color: none' if state else 'color: blue' self._lbl_elastic_scattering_c1.setStyleSheet(style) self._txt_elastic_scattering_c1.setReadOnly(state) self._lbl_elastic_scattering_c2.setStyleSheet(style) self._txt_elastic_scattering_c2.setReadOnly(state) self._lbl_cutoff_energy_inelastic.setStyleSheet(style) self._txt_cutoff_energy_inelastic.setReadOnly(state) self._cb_cutoff_energy_inelastic.setEnabled(not state) self._lbl_cutoff_energy_bremsstrahlung.setStyleSheet(style) self._txt_cutoff_energy_bremsstrahlung.setReadOnly(state) self._cb_cutoff_energy_bremsstrahlung.setEnabled(not state) self._lbl_maximum_step_length.setStyleSheet(style) self._txt_maximum_step_length.setReadOnly(state) self._cb_maximum_step_length_unit.setEnabled(not state) self._tbl_forcing.setEnabled(not state) self._tlb_forcing.setVisible(not state) def isReadOnly(self): return _MaterialDialog.isReadOnly(self) and \ self._txt_elastic_scattering_c1.isReadOnly() and \ self._txt_elastic_scattering_c2.isReadOnly() and \ self._txt_cutoff_energy_inelastic.isReadOnly() and \ self._txt_cutoff_energy_bremsstrahlung.isReadOnly() and \ self._txt_maximum_step_length.isReadOnly() and \ not self._tbl_forcing.isEnabled() and \ not self._tlb_forcing.isVisible()
class LimitWizardPage(_ExpandableOptionsWizardPage): class _LimitComboBoxModel(QAbstractListModel): def __init__(self, limits_text=None): QAbstractListModel.__init__(self) if limits_text is None: limits_text = {} self._limits_text = limits_text.copy() self._limits = list(limits_text.keys()) def rowCount(self, *args, **kwargs): return len(self._limits) def data(self, index, role=Qt.DisplayRole): if not index.isValid() or \ not (0 <= index.row() < self.rowCount()): return None if role == Qt.TextAlignmentRole: return Qt.AlignCenter if role != Qt.DisplayRole: return None limit_class = self._limits[index.row()] return self._limits_text[limit_class] def add(self, limit_class): if limit_class not in self._limits_text: raise ValueError('No text defined for limit: %s' % limit_class) self._limits.append(limit_class) self.reset() def remove(self, limit_class): self._limits.remove(limit_class) self.reset() def limitClass(self, index): return self._limits[index] class _LimitTableModel(QAbstractTableModel): def __init__(self): QAbstractTableModel.__init__(self) self._limits = [] def rowCount(self, *args, **kwargs): return len(self._limits) def columnCount(self, *args, **kwargs): return 1 def data(self, index, role=Qt.DisplayRole): if not index.isValid() or \ not (0 <= index.row() < len(self._limits)): return None if role == Qt.TextAlignmentRole: return Qt.AlignCenter if role == Qt.DisplayRole or role == Qt.ToolTipRole: limit = self._limits[index.row()] return str(limit) if limit is not None else '' return None def headerData(self, section , orientation, role): if role != Qt.DisplayRole: return None if orientation == Qt.Vertical: return str(section + 1) def flags(self, index): if not index.isValid(): return Qt.ItemIsEnabled return Qt.ItemFlags(QAbstractTableModel.flags(self, index) | Qt.ItemIsEditable) def setData(self, index, value, role=Qt.EditRole): if not index.isValid() or \ not (0 <= index.row() < len(self._limits)): return False row = index.row() self._limits[row] = value self.dataChanged.emit(index, index) return True def insertRows(self, row, count=1, parent=None): if parent is None: parent = QModelIndex() self.beginInsertRows(parent, row, row + count - 1) for _ in range(count): self._limits.insert(row, None) self.endInsertRows() return True def removeRows(self, row, count=1, parent=None): if parent is None: parent = QModelIndex() self.beginRemoveRows(parent, row, row + count - 1) for index in reversed(range(row, row + count)): self._limits.pop(index) self.endRemoveRows() return True def append(self, limit): self.insert(self.rowCount(), limit) def insert(self, index, limit): self.insertRows(index) self.setData(self.createIndex(index, 0), limit) def remove(self, limit): index = self._limits.index(limit) self.removeRows(index) def modify(self, index, limit): self.setData(self.createIndex(index, 0), limit) def clear(self): self.removeRows(0, self.rowCount()) def limits(self): limits = set(self._limits) limits.discard(None) return limits def limit(self, index): return self._limits[index.row()] class _LimitTableDelegate(QItemDelegate): def __init__(self, parent=None): QItemDelegate.__init__(self, parent) def createEditor(self, parent, option, index): return None def setEditorData(self, editor, index): pass def setModelData(self, editor, model, index): return None def __init__(self, options, parent=None): _ExpandableOptionsWizardPage.__init__(self, options, parent) self.setTitle('Limit') def _initUI(self): # Variables self._widgets = {} tbl_model = self._LimitTableModel() # Widgets self._cb_limit = QComboBox() self._cb_limit.setModel(self._LimitComboBoxModel()) btn_limit_add = QPushButton() btn_limit_add.setIcon(getIcon("list-add")) self._tbl_limit = QTableView() self._tbl_limit.setModel(tbl_model) self._tbl_limit.setItemDelegate(self._LimitTableDelegate()) header = self._tbl_limit.horizontalHeader() header.setResizeMode(QHeaderView.Stretch) header.hide() policy = self._tbl_limit.sizePolicy() policy.setVerticalStretch(True) self._tbl_limit.setSizePolicy(policy) tlb_limit = QToolBar() spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) tlb_limit.addWidget(spacer) act_remove = tlb_limit.addAction(getIcon("list-remove"), "Remove limit") act_clear = tlb_limit.addAction(getIcon("edit-clear"), "Clear") # Layouts layout = _ExpandableOptionsWizardPage._initUI(self) sublayout = QHBoxLayout() sublayout.addWidget(self._cb_limit, 1) sublayout.addWidget(btn_limit_add) layout.addRow("Select", sublayout) layout.addRow(self._tbl_limit) layout.addRow(tlb_limit) # Signals btn_limit_add.released.connect(self._onLimitAdd) act_remove.triggered.connect(self._onLimitRemove) act_clear.triggered.connect(self._onLimitClear) self._tbl_limit.doubleClicked.connect(self._onLimitDoubleClicked) tbl_model.dataChanged.connect(self.valueChanged) tbl_model.rowsInserted.connect(self.valueChanged) tbl_model.rowsRemoved.connect(self.valueChanged) return layout def _onLimitAdd(self): tbl_model = self._tbl_limit.model() cb_model = self._cb_limit.model() index = self._cb_limit.currentIndex() try: limit_class = cb_model.limitClass(index) except IndexError: return widget_class = self._widgets[limit_class] wdg_limit = widget_class() dialog = _LimitDialog(wdg_limit) if not dialog.exec_(): return limit = dialog.limit() tbl_model.append(limit) # Insert table row cb_model.remove(limit.__class__) # Remove limit from combo box def _onLimitRemove(self): selection = self._tbl_limit.selectionModel().selection().indexes() if len(selection) == 0: QMessageBox.warning(self, "Limit", "Select a row") return tbl_model = self._tbl_limit.model() cb_model = self._cb_limit.model() for row in sorted(map(methodcaller('row'), selection), reverse=True): limit = tbl_model.limit(tbl_model.createIndex(row, 0)) cb_model.add(limit.__class__) # Show limit to combo box tbl_model.removeRow(row) # Remove row if self._cb_limit.currentIndex() < 0: self._cb_limit.setCurrentIndex(0) def _onLimitClear(self): tbl_model = self._tbl_limit.model() cb_model = self._cb_limit.model() for row in reversed(range(tbl_model.rowCount())): limit = tbl_model.limit(tbl_model.createIndex(row, 0)) cb_model.add(limit.__class__) # Show limit to combo box tbl_model.removeRow(row) # Remove row if self._cb_limit.currentIndex() < 0: self._cb_limit.setCurrentIndex(0) def _onLimitDoubleClicked(self, index): tbl_model = self._tbl_limit.model() limit = tbl_model.limit(index) widget_class = self._widgets[limit.__class__] wdg_limit = widget_class() wdg_limit.setValue(limit) dialog = _LimitDialog(wdg_limit) if not dialog.exec_(): return tbl_model.modify(index.row(), dialog.limit()) def initializePage(self): _ExpandableOptionsWizardPage.initializePage(self) # Clear self._widgets.clear() limits_text = {} # Populate combo box it = self._iter_widgets('pymontecarlo.ui.gui.options.limit', 'LIMITS') for limit_class, widget_class, programs in it: widget = widget_class() self._widgets[limit_class] = widget_class program_text = ', '.join(map(attrgetter('name'), programs)) text = '{0} ({1})'.format(widget.accessibleName(), program_text) limits_text[limit_class] = text del widget cb_model = self._LimitComboBoxModel(limits_text) self._cb_limit.setModel(cb_model) self._cb_limit.setCurrentIndex(0) # Add limit(s) tbl_model = self._tbl_limit.model() tbl_model.clear() for limit in self.options().limits: tbl_model.append(limit) def validatePage(self): tbl_model = self._tbl_limit.model() self.options().limits.clear() for limit in tbl_model.limits(): if not limit.__class__ in self._widgets: continue self.options().limits.add(limit) return True def expandCount(self): if self._tbl_limit.model().rowCount() == 0: return 0 try: count = 1 for limit in self._tbl_limit.model().limits(): count *= len(expand(limit)) return count except: return 0
class FindOrderDialog(QDialog): def __init__(self,parent): global dao super(FindOrderDialog,self).__init__(parent) title = _("Find order") self.setWindowTitle(title) top_layout = QVBoxLayout() self.title_widget = TitleWidget(title,self) top_layout.addWidget(self.title_widget) hlayout = QHBoxLayout() hlayout.addWidget(QLabel(_("Search"))) self.search_criteria = QLineEdit() self.search_criteria.setObjectName("search_criteria") hlayout.addWidget(self.search_criteria) top_layout.addLayout(hlayout) self.search_results_view = QTableView() self.headers_view = QHeaderView(Qt.Orientation.Horizontal) self.header_model = make_header_model([_("Preorder Nr"),_("Order Nr"),_("Customer Nr"),_("Customer"),_("Order Part")]) self.headers_view.setModel(self.header_model) # qt's doc : The view does *not* take ownership (bt there's something with the selecion mode self.search_results_model = QStandardItemModel() self.search_results_view.setModel(self.search_results_model) self.search_results_view.setEditTriggers(QAbstractItemView.NoEditTriggers) self.search_results_view.setHorizontalHeader(self.headers_view) self.search_results_view.verticalHeader().hide() # self.search_results_view.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents) self.search_results_view.horizontalHeader().setResizeMode(3, QHeaderView.Stretch) self.search_results_view.horizontalHeader().setResizeMode(4, QHeaderView.Stretch) self.search_results_view.setSelectionBehavior(QAbstractItemView.SelectRows) self.buttons = QDialogButtonBox() self.buttons.addButton( QDialogButtonBox.StandardButton.Cancel) self.buttons.addButton( QDialogButtonBox.Ok) self.buttons.button(QDialogButtonBox.Ok).setObjectName("go_search") top_layout.addWidget(self.search_results_view) top_layout.setStretch(2,1000) top_layout.addWidget(self.buttons) self.setLayout(top_layout) self.buttons.accepted.connect(self.accept) self.buttons.rejected.connect(self.reject) self.search_results_view.activated.connect(self.row_activated) self.search_criteria.returnPressed.connect(self.search_criteria_submitted) self.setMinimumSize(800,640) def find_by_text(self,text): text = text.strip() try: too_many_results, res = dao.order_part_dao.find_ids_by_text(text.strip()) if too_many_results: showWarningBox(_("Too many results"),_("The query you've given brought back too many results. Only a part of them is displayed. Consider refining your query"),object_name="too_many_results") return dao.order_part_dao.find_by_ids(res) except DataException as de: if de.code == DataException.CRITERIA_IS_EMPTY: showErrorBox(_("Error in the filter !"), _("The filter can't be empty"),object_name="filter_is_empty") elif de.code == DataException.CRITERIA_IS_TOO_SHORT: showErrorBox(_("Error in the filter !"), _("The filter is too short"),object_name="filter_is_too_short") elif de.code == DataException.CRITERIA_IS_TOO_LONG: showErrorBox(_("Error in the filter !"), _("The filter is too long"),object_name="filter_is_too_long") return [] # order_part_match = [] # matches = [] # super_matches = [] # import re # re_order_part_identifier = re.compile("^([0-9]+)([A-Z]+)$") # re_label_identifier = re.compile("^[0-9]+$") # if re_order_part_identifier.match(text.upper()): # # Look for an exact (and unique) match on the order part full identifier # p = dao.order_part_dao.find_by_full_id(text.upper()) # if p: # # Mimick SQLAlchemy's KeyTuples # # FIXME It seems that I use something that's internal to SQLA # # Search SQLA's doc for KeyedTuple to find about collections.namedtuple() # from sqlalchemy.util._collections import KeyedTuple # kt = KeyedTuple([p.order_id, p.order.preorder_label, p.order.accounting_label, p.order.customer_order_name, p.order.customer.fullname, p.order.creation_date, p.description, p.order_part_id, p.label], # labels=['order_id','preorder_label','accounting_label','customer_order_name','fullname','creation_date','description','order_part_id','label']) # order_part_match = [ kt ] # if re_label_identifier.match(text): # for r in dao.order_dao.find_by_labels(int(text)): # super_matches.append(r) # for r in dao.order_dao.find_by_customer_name(text): # # mainlog.debug('customer name match on {}'.format(text)) # matches.append(r) # for r in dao.order_dao.find_by_customer_order_name(text): # # mainlog.debug('customer name match on {}'.format(text)) # matches.append(r) # for r in dao.order_part_dao.find_by_description(text): # matches.append(r) # # Finally we order the matches to bring the most relevant # # first. The "most relevant" is really a business order. # return order_part_match + super_matches + \ # sorted(matches, lambda a,b: - cmp(a.order_id,b.order_id)) def _search_results_to_array(self,search_results): array = [] for res in search_results: # mainlog.debug("_search_results_to_array {}".format(res.creation_date)) i = QStandardItem(res.preorder_part_label) row = [i, QStandardItem(res.accounting_part_label), QStandardItem(res.customer_order_name), QStandardItem(res.fullname)] if 'order_part_id' in res.__dict__: # It's an order part i.setData( res.order_part_id, Qt.UserRole) i.setData( 'order_part', Qt.UserRole+1) row.append( QStandardItem(res.description)) else: # It's an order i.setData( res.order_id, Qt.UserRole) i.setData( 'order', Qt.UserRole+1) row.append( QStandardItem()) array.append(row) return array def load_search_results(self,text=None): global dao if text is None: text = self.search_criteria.text() db_results = self.find_by_text(text) array = self._search_results_to_array(db_results) self.search_results_model.removeRows(0,self.search_results_model.rowCount()) for row in array: self.search_results_model.appendRow(row) mainlog.debug("Loaded model : {}".format(self.search_results_model.rowCount())) self.search_results_view.resizeColumnsToContents() if self.search_results_model.rowCount() > 0: self.search_results_view.setCurrentIndex(self.search_results_model.index(0,0)) self.search_results_view.setFocus(Qt.OtherFocusReason) if self.search_results_model.rowCount() == 1: self.accept() def selected_item(self): mainlog.debug("FindOrder.selected_item") ndx = self.search_results_view.currentIndex() if ndx.isValid(): ndx = self.search_results_view.model().index( ndx.row(), 0) item = ndx.data(Qt.UserRole) item_type = ndx.data(Qt.UserRole+1) if item_type == 'order': mainlog.debug("FindOrder.selected_item order_id={}".format(item)) return dao.order_dao.find_by_id(item) elif item_type == 'order_part': mainlog.debug("FindOrder.selected_item order_part_id={}".format(item)) return dao.order_part_dao.find_by_id(item) else: mainlog.error("Unsupported item type {}".format(item_type)) else: mainlog.error("Invalid index") return None @Slot() def accept(self): # mainlog.debug("accept") # self.load_search_results() # mainlog.debug("accept - done") return super(FindOrderDialog,self).accept() @Slot() def reject(self): return super(FindOrderDialog,self).reject() @Slot() def search_criteria_submitted(self): mainlog.debug("search_criteria_submitted") self.load_search_results() @Slot(QModelIndex) def row_activated(self,ndx): mainlog.debug("row_activated") self.accept() def keyPressEvent(self,event): # The goal here is to make sure the accept signal is called only # if the user clicks on the "OK" button /with the mouse/ and, # not with the keyboard if event.key() in (Qt.Key_Enter, Qt.Key_Return): return else: super(FindOrderDialog,self).keyPressEvent(event)