def setupTabs(self):
""" Setup the various tabs in the AddressWidget. """
groups = ["ABC", "DEF", "GHI", "JKL", "MNO", "PQR", "STU", "VW", "XYZ"]
for group in groups:
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
tableView = QTableView()
tableView.setModel(proxyModel)
tableView.setSortingEnabled(True)
tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
tableView.horizontalHeader().setStretchLastSection(True)
tableView.verticalHeader().hide()
tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
tableView.setSelectionMode(QAbstractItemView.SingleSelection)
# This here be the magic: we use the group name (e.g. "ABC") to
# build the regex for the QSortFilterProxyModel for the group's
# tab. The regex will end up looking like "^[ABC].*", only
# allowing this tab to display items where the name starts with
# "A", "B", or "C". Notice that we set it to be case-insensitive.
reFilter = "^[%s].*" % group
proxyModel.setFilterRegExp(QRegExp(reFilter, Qt.CaseInsensitive))
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
tableView.selectionModel().selectionChanged.connect(self.selectionChanged)
self.addTab(tableView, group)
def setupTabs(self):
""" Setup the various tabs in the AddressWidget. """
groups = ["ABC", "DEF", "GHI", "JKL", "MNO", "PQR", "STU", "VW", "XYZ"]
for group in groups:
proxyModel = QSortFilterProxyModel(self)
proxyModel.setSourceModel(self.tableModel)
proxyModel.setDynamicSortFilter(True)
tableView = QTableView()
tableView.setModel(proxyModel)
tableView.setSortingEnabled(True)
tableView.setSelectionBehavior(QAbstractItemView.SelectRows)
tableView.horizontalHeader().setStretchLastSection(True)
tableView.verticalHeader().hide()
tableView.setEditTriggers(QAbstractItemView.NoEditTriggers)
tableView.setSelectionMode(QAbstractItemView.SingleSelection)
# This here be the magic: we use the group name (e.g. "ABC") to
# build the regex for the QSortFilterProxyModel for the group's
# tab. The regex will end up looking like "^[ABC].*", only
# allowing this tab to display items where the name starts with
# "A", "B", or "C". Notice that we set it to be case-insensitive.
reFilter = "^[%s].*" % group
proxyModel.setFilterRegExp(QRegExp(reFilter, Qt.CaseInsensitive))
proxyModel.setFilterKeyColumn(0) # Filter on the "name" column
proxyModel.sort(0, Qt.AscendingOrder)
#tableView.selectionModel().selectionChanged.connect(self.selectionChanged)
self.addTab(tableView, group)
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 QuickOrderViewWidget(SubFrame):
def __init__(self, parent):
super(QuickOrderViewWidget, self).__init__("Quick view", None, parent)
self._table_model = QStandardItemModel(1, 2, None)
self.table_view = QTableView(self)
self.table_view.setModel(self._table_model)
self.layout().addWidget(self.table_view)
self._table_model.setHorizontalHeaderLabels(
['Part Nr.', 'Description'])
self.table_view.verticalHeader().hide()
headers_view = self.table_view.horizontalHeader()
headers_view.setResizeMode(0, QHeaderView.ResizeToContents)
headers_view.setResizeMode(1, QHeaderView.Stretch)
def selected_order(self, cur, prev):
if cur.isValid():
order_id = cur.model().index(cur.row(), 0).data(Qt.UserRole)
self._table_model.removeRows(0, self._table_model.rowCount())
row = 0
for label, description in dao.order_dao.load_quick_view(order_id):
self._table_model.appendRow(
[QStandardItem(label),
QStandardItem(description)])
class Blew(QWidget):
def __init__(self):
super(Blew, self).__init__()
self.setWindowModality(Qt.NonModal)
self.setWindowFlags(
Qt.FramelessWindowHint) # Qt.Tool | Qt.FramelessWindowHint
l = QHBoxLayout()
self.items_view = QTableView()
# Make the dropdown nice
l.setContentsMargins(0, 0, 0, 0)
self.items_view.horizontalHeader().setStretchLastSection(True)
self.items_view.horizontalHeader().hide()
self.items_view.verticalHeader().hide()
self.items_view.setShowGrid(False)
self.setMinimumSize(300, 100)
self.model = QuickComboModel(self)
self.items_view.setModel(self.model)
l.addWidget(self.items_view)
self.setLayout(l)
def get_current_completion(self):
""" Get the currently selected completion """
return self.items_view.currentIndex().data()
@Slot(list)
def set_possible_completions(self, completions):
if completions:
self.model.buildModelFromArray(completions)
# self.show()
else:
self.model.clear()
self.hide()
completion_discarded = Signal()
def keyPressEvent(self, event):
if event.key() == Qt.Key_Escape:
event.ignore()
self.hide()
self.completion_discarded.emit()
return super(Blew, self).keyPressEvent(event)
def _addtabondemand(self, thread):
"""Adds a new tab for the given thread, if it doesn't exist yet.
If it does, it will be made the current tab.
@param thread Instance of FourChanThreahHeader
"""
i = thread.id_()
if not i in self._openthreads.keys():
table = QTableView(self)
table.setModel(LiveFeedModel(self))
table.setAlternatingRowColors(True)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.setIconSize(QSize(192, 192))
table.horizontalHeader().setVisible(False)
table.horizontalHeader().setDefaultSectionSize(192)
table.horizontalHeader().setStretchLastSection(True)
table.verticalHeader().setVisible(False)
table.verticalHeader().setDefaultSectionSize(192)
table.doubleClicked.connect(self._showlivepost)
idx = self.tabPosts.addTab(table, "/%s/%s" % (thread.forum(), i))
self._openthreads[i] = (idx, thread, table)
fct = FourChanThread(
FourChanThreadUrl(thread.url()), self._masterobserver)
fct.postadded.connect(self._updatethread)
self._masterobserver.addobserver(
FourChanThreadObserver(fct, parent=self))
fct.refresh(True)
else:
idx = self._openthreads[i][0]
self.tabPosts.setCurrentIndex(idx)
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 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 WarningWizardPage(_OptionsWizardPage):
class _WarningTableModel(QAbstractTableModel):
def __init__(self, warns=None):
QAbstractTableModel.__init__(self)
if warns is None:
warns = []
self._warns = warns
def rowCount(self, *args, **kwargs):
return len(self._warns)
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._warns)):
return None
if role == Qt.TextAlignmentRole:
return Qt.AlignCenter
if role != Qt.DisplayRole:
return None
return str(self._warns[index.row()][index.column()])
def headerData(self, section , orientation, role):
if role != Qt.DisplayRole:
return None
if orientation == Qt.Horizontal:
if section == 0:
return 'Program'
elif section == 1:
return 'Warning'
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 __init__(self, options, parent=None):
_OptionsWizardPage.__init__(self, options, parent=parent)
self.setTitle("Conversion warnings")
# Widgets
self._lbl_count = SimulationCountLabel()
self._lbl_count.setAlignment(Qt.AlignCenter)
# Layouts
layout = self.layout()
frm_line = QFrame()
frm_line.setFrameStyle(QFrame.HLine)
frm_line.setFrameShadow(QFrame.Sunken)
layout.addWidget(frm_line)
sublayout = QHBoxLayout()
sublayout.setContentsMargins(10, 0, 10, 0)
sublayout.addWidget(self._lbl_count)
layout.addLayout(sublayout)
def _initUI(self):
# Widgets
self._tbl_warnings = QTableView()
self._tbl_warnings.setModel(self._WarningTableModel())
header = self._tbl_warnings.horizontalHeader()
header.setResizeMode(1, QHeaderView.Stretch)
policy = self._tbl_warnings.sizePolicy()
policy.setVerticalStretch(True)
self._tbl_warnings.setSizePolicy(policy)
# Layouts
layout = _OptionsWizardPage._initUI(self)
layout.addRow(self._tbl_warnings)
return layout
def initializePage(self):
count = 0
warns = []
for program in self.options().programs:
converter = program.converter_class()
warnings.simplefilter("always")
with warnings.catch_warnings(record=True) as ws:
list_options = converter.convert(self.options())
count += len(list_options)
for w in ws:
warns.append((program, w.message))
model = self._WarningTableModel(warns)
self._tbl_warnings.setModel(model)
self._lbl_count.setValue(count)
def validatePage(self):
return self._lbl_count.value() > 0
class TemplateSelectDialog(QDialog):
def refresh_templates_list(self):
documents = documents_service.all_templates()
self.model.removeRows(0, self.model.rowCount())
if documents:
for doc in sorted(list(documents), key=lambda d: d.filename):
self._add_one_document(doc.filename, doc.template_document_id,
doc.file_size, doc.description)
def __init__(self, parent=None):
super(TemplateSelectDialog, self).__init__(parent)
self.setWindowTitle(_("Select a template"))
self.template_id = []
self.model = QStandardItemModel()
self.view = QTableView()
self.view.setModel(self.model)
self.view.verticalHeader().setVisible(False)
self.view.horizontalHeader().setVisible(False)
self.view.setMinimumSize(500, 200)
self.view.setShowGrid(True)
self.view.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
l = QVBoxLayout()
l.addWidget(QLabel(_("Please select one or more template.")))
self.view.doubleClicked.connect(self._doubleClicked)
l.addWidget(QLabel(u"<h3>{}</h3>".format(_("Documents Templates"))))
l.addWidget(self.view)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.StandardButton.Cancel)
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
l.addWidget(self.buttons)
self.setLayout(l)
def _add_one_document(self, file_name, doc_id, file_size, description):
""" Adds a document to the list
"""
# file_name is either an absolute path or just a file name
# If it is an absolute path, then the file is expected
# to exist locally (at it absolute path location of course).
# If not, then the file is expected to be a remote file
# and shall be downloaded before opening.
mainlog.debug(u"{} {} {} {}".format(file_name, doc_id, file_size,
description))
short_name = file_name
if os.path.isabs(file_name):
short_name = os.path.basename(file_name)
if not os.path.isfile(file_name):
raise Exception(u"The file {} doesn't exist".format(file_name))
items = [QStandardItem(short_name)]
items.append(QStandardItem(description))
self.model.appendRow(items)
self.model.setData(self.model.index(self.model.rowCount() - 1, 0),
doc_id, Qt.UserRole + 1)
self.view.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.view.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.view.resizeRowsToContents()
@Slot()
def accept(self):
selected_rows = self.view.selectionModel().selectedRows()
if selected_rows:
self.template_id = []
for row in selected_rows:
ndx_row = row.row()
self.template_id.append(
self.model.data(self.model.index(ndx_row, 0),
Qt.UserRole + 1))
else:
self.template_id = []
return super(TemplateSelectDialog, self).accept()
@Slot()
def reject(self):
return super(TemplateSelectDialog, self).reject()
@Slot(QModelIndex)
def _doubleClicked(self, ndx):
self.accept()
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 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 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 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()"))
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 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 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)