class SchemeWidget(QWidget):
def __init__(self, parent, schemes):
QWidget.__init__(self)
self._parent = parent
self._schemes = schemes
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 2)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(self._schemes, self._table)
btnUninstall = QPushButton('Download')
btnUninstall.setMaximumWidth(100)
vbox.addWidget(btnUninstall)
self.connect(btnUninstall, SIGNAL("clicked()"), self._download_scheme)
def _download_scheme(self):
rows = self._table.rowCount()
pos = rows - 1
schemes = []
for i in xrange(rows):
if self._table.item(pos - i, 0) is not None and \
self._table.item(pos - i, 0).checkState() == Qt.Checked:
schemes.append(self._schemes.pop(pos - i))
self._table.removeRow(pos - i)
self._parent.download_scheme(schemes)
class InstalledWidget(QWidget):
def __init__(self, parent, installed):
QWidget.__init__(self)
self._parent = parent
self._installed = installed
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(self._installed, self._table)
btnUninstall = QPushButton('Uninstall')
btnUninstall.setMaximumWidth(100)
vbox.addWidget(btnUninstall)
self.connect(btnUninstall, SIGNAL("clicked()"), self._uninstall_plugins)
def add_table_items(self, plugs):
self._installed += plugs
set_data(self._installed, self._table)
def _uninstall_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
for i in xrange(rows):
if self._table.item(pos-i, 0) is not None and \
self._table.item(pos-i, 0).checkState() == Qt.Checked:
self._parent.mark_as_available(self._installed.pop(pos-i))
self._table.removeRow(pos-i)
def reset_table(self, installed):
self._installed = installed
while self._table.rowCount() > 0:
self._table.removeRow(0)
set_data(self._installed, self._table)
class UpdatesWidget(QWidget):
def __init__(self, parent, updates):
QWidget.__init__(self)
self._parent = parent
self._updates = updates
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(updates, self._table)
btnUpdate = QPushButton('Update')
btnUpdate.setMaximumWidth(100)
vbox.addWidget(btnUpdate)
self.connect(btnUpdate, SIGNAL("clicked()"), self._update_plugins)
def _update_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
plugins = []
for i in xrange(rows):
if self._table.item(pos-i, 0) is not None and \
self._table.item(pos-i, 0).checkState() == Qt.Checked:
plugins.append(self._updates.pop(pos-i))
self._table.removeRow(pos-i)
self._parent.update_plugin(plugins)
class InstalledWidget(QWidget):
def __init__(self, parent, installed):
QWidget.__init__(self)
self._parent = parent
self._installed = installed
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(self._installed, self._table)
btnUninstall = QPushButton('Uninstall')
btnUninstall.setMaximumWidth(100)
vbox.addWidget(btnUninstall)
self.connect(btnUninstall, SIGNAL("clicked()"), self._uninstall_plugins)
def add_table_items(self, plugs):
self._installed += plugs
set_data(self._installed, self._table)
def _uninstall_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
for i in xrange(rows):
if self._table.item(pos-i, 0) is not None and \
self._table.item(pos-i, 0).checkState() == Qt.Checked:
self._parent.mark_as_available(self._installed.pop(pos-i))
self._table.removeRow(pos-i)
def reset_table(self, installed):
self._installed = installed
while self._table.rowCount() > 0:
self._table.removeRow(0)
set_data(self._installed, self._table)
class UpdatesWidget(QWidget):
def __init__(self, parent, updates):
QWidget.__init__(self)
self._parent = parent
self._updates = updates
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(updates, self._table)
btnUpdate = QPushButton('Update')
btnUpdate.setMaximumWidth(100)
vbox.addWidget(btnUpdate)
self.connect(btnUpdate, SIGNAL("clicked()"), self._update_plugins)
def _update_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
plugins = []
for i in xrange(rows):
if self._table.item(pos-i, 0) is not None and \
self._table.item(pos-i, 0).checkState() == Qt.Checked:
plugins.append(self._updates.pop(pos-i))
self._table.removeRow(pos-i)
self._parent.update_plugin(plugins)
class SchemeWidget(QWidget):
def __init__(self, parent, schemes):
QWidget.__init__(self)
self._parent = parent
self._schemes = schemes
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 2)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(self._schemes, self._table)
btnUninstall = QPushButton('Download')
btnUninstall.setMaximumWidth(100)
vbox.addWidget(btnUninstall)
self.connect(btnUninstall, SIGNAL("clicked()"), self._download_scheme)
def _download_scheme(self):
rows = self._table.rowCount()
pos = rows - 1
schemes = []
for i in xrange(rows):
if self._table.item(pos - i, 0) is not None and \
self._table.item(pos - i, 0).checkState() == Qt.Checked:
schemes.append(self._schemes.pop(pos - i))
self._table.removeRow(pos - i)
self._parent.download_scheme(schemes)
class AvailableWidget(QWidget):
def __init__(self, parent, available):
QWidget.__init__(self)
self._parent = parent
self._available = available
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(available, self._table)
btnInstall = QPushButton('Install')
btnInstall.setMaximumWidth(100)
vbox.addWidget(btnInstall)
hbox = QHBoxLayout()
hbox.addWidget(QLabel('Add an external Plugin. URL Zip File:'))
self.link = QLineEdit()
hbox.addWidget(self.link)
btnAdd = QPushButton('Add')
hbox.addWidget(btnAdd)
vbox.addLayout(hbox)
lblExternalPlugin = QLabel('(Write the URL of the Plugin and press "Add")')
lblExternalPlugin.setAlignment(Qt.AlignRight)
vbox.addWidget(lblExternalPlugin)
self.connect(btnInstall, SIGNAL("clicked()"), self._install_plugins)
self.connect(btnAdd, SIGNAL("clicked()"), self._install_external)
def _install_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
plugins = []
for i in xrange(rows):
if self._table.item(pos-i, 0) is not None and \
self._table.item(pos-i, 0).checkState() == Qt.Checked:
plugins.append(self._available.pop(pos-i))
self._table.removeRow(pos-i)
self._parent.download_plugins(plugins)
def _install_external(self):
if self.link.text().isEmpty():
QMessageBox.information(self, 'External Plugins', 'URL from Plugin missing...')
return
plug = [
manage_files.get_module_name(str(self.link.text())),
'External Plugin',
'1.0',
str(self.link.text())
]
self._parent.download_plugins(plug)
self.link.setText('')
def add_table_items(self, plugs):
self._available += plugs
set_data(self._available, self._table)
class WellLogEditDialog(QDialog):
def __init__(self, current_well_name, current_log_name):
super(WellLogEditDialog, self).__init__()
self.well = ppp.Well(
str(CONF.well_dir / ".{}".format(current_well_name)))
self.current_log_name = current_log_name
self.well_log = self.well.get_log(current_log_name)
self.resize(300, 400)
self.initUI()
self.button_box.accepted.connect(self.save_edit)
self.button_box.rejected.connect(self.close)
def initUI(self):
self.setWindowIcon(QIcon(':/icon/edit_icon'))
self.setWindowTitle("Edit Log {}".format(self.current_log_name))
self.layout = QGridLayout(self)
# add a QTableWidget
self.tableWidget = QTableWidget(self)
self.tableWidget.setColumnCount(2)
self.tableWidget.setRowCount(0)
self.tableWidget.setHorizontalHeaderItem(0, QTableWidgetItem("Depth"))
self.tableWidget.setHorizontalHeaderItem(1, QTableWidgetItem("Data"))
n = len(self.well_log.depth)
self.tableWidget.setRowCount(n)
for i, (de,
da) in enumerate(zip(self.well_log.depth, self.well_log.data)):
self.tableWidget.setItem(i, 0, QTableWidgetItem(str(de)))
self.tableWidget.setItem(i, 1, QTableWidgetItem(str(da)))
self.layout.addWidget(self.tableWidget)
# add QDialogButtonBox
self.button_box = QDialogButtonBox(self)
self.button_box.setStandardButtons(QDialogButtonBox.Save
| QDialogButtonBox.Cancel)
self.layout.addWidget(self.button_box)
def save_edit(self):
depth_tb = [float(self.tableWidget.item(irow, 0).text()) \
for irow in range(self.tableWidget.rowCount())]
data_tb = [float(self.tableWidget.item(irow, 1).text()) \
for irow in range(self.tableWidget.rowCount())]
temp_log = ppp.Log()
temp_log.depth = depth_tb
temp_log.data = data_tb
if temp_log != self.well_log:
reply = QMessageBox.question(
self, "Save",
"Log Data has been edited,\nAre you willing to save changes?",
QMessageBox.Yes, QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.well.update_log(self.current_log_name, temp_log)
self.well.save_well()
self.close()
class AvailableWidget(QWidget):
def __init__(self, parent, available):
QWidget.__init__(self)
self._parent = parent
self._available = available
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(available, self._table)
btnInstall = QPushButton('Install')
btnInstall.setMaximumWidth(100)
vbox.addWidget(btnInstall)
hbox = QHBoxLayout()
hbox.addWidget(QLabel('Add an external Plugin. URL Zip File:'))
self.link = QLineEdit()
hbox.addWidget(self.link)
btnAdd = QPushButton('Add')
hbox.addWidget(btnAdd)
vbox.addLayout(hbox)
self.connect(btnInstall, SIGNAL("clicked()"), self._install_plugins)
self.connect(btnAdd, SIGNAL("clicked()"), self._install_external)
def _install_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
plugins = []
for i in xrange(rows):
if self._table.item(pos-i, 0) is not None and \
self._table.item(pos-i, 0).checkState() == Qt.Checked:
plugins.append(self._available.pop(pos-i))
self._table.removeRow(pos-i)
self._parent.download_plugins(plugins)
def _install_external(self):
plug = [
manage_files.get_module_name(str(self.link.text())),
'External Plugin',
'1.0',
str(self.link.text())
]
self._parent.download_plugins(plug)
self.link.setText('')
def add_table_items(self, plugs):
self._available += plugs
set_data(self._available, self._table)
class AvailableWidget(QWidget):
def __init__(self, parent, available):
QWidget.__init__(self)
self._parent = parent
self._available = available
vbox = QVBoxLayout(self)
self._table = QTableWidget(1, 3)
self._table.removeRow(0)
vbox.addWidget(self._table)
set_data(available, self._table)
btnInstall = QPushButton("Install")
btnInstall.setMaximumWidth(100)
vbox.addWidget(btnInstall)
hbox = QHBoxLayout()
hbox.addWidget(QLabel("Add an external Plugin. URL Zip File:"))
self.link = QLineEdit()
hbox.addWidget(self.link)
btnAdd = QPushButton("Add")
hbox.addWidget(btnAdd)
vbox.addLayout(hbox)
lblExternalPlugin = QLabel('(Write the URL of the Plugin and press "Add")')
lblExternalPlugin.setAlignment(Qt.AlignRight)
vbox.addWidget(lblExternalPlugin)
self.connect(btnInstall, SIGNAL("clicked()"), self._install_plugins)
self.connect(btnAdd, SIGNAL("clicked()"), self._install_external)
def _install_plugins(self):
rows = self._table.rowCount()
pos = rows - 1
plugins = []
for i in xrange(rows):
if self._table.item(pos - i, 0) is not None and self._table.item(pos - i, 0).checkState() == Qt.Checked:
plugins.append(self._available.pop(pos - i))
self._table.removeRow(pos - i)
self._parent.download_plugins(plugins)
def _install_external(self):
if self.link.text().isEmpty():
QMessageBox.information(self, "External Plugins", "URL from Plugin missing...")
return
plug = [manage_files.get_module_name(str(self.link.text())), "External Plugin", "1.0", str(self.link.text())]
self._parent.download_plugins(plug)
self.link.setText("")
def add_table_items(self, plugs):
self._available += plugs
set_data(self._available, self._table)
class ApHlasConfDlg(QDialog):
def __init__(self, width, height, parent = None):
super(ApHlasConfDlg, self).__init__(parent)
table1 = QTableWidget(5, 5)
table1.connect(table1, SIGNAL("cellActivated(int, int)"), self.showTags)
table1.connect(table1, SIGNAL("cellClicked(int, int)"), self.showTags)
it1 = QTableWidgetItem("Hello")
table1.setItem(0, 0, it1)
hdview = QHeaderView(Qt.Horizontal)
hdview.setStretchLastSection(True)
self.tagsTable = QTableWidget(5,1)
self.tagsTable.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.tagsTable.setHorizontalHeader(hdview)
self.tagsTable.setHorizontalHeaderLabels(['tags'])
l = QHBoxLayout(self)
l.addWidget(table1)
l.addWidget(self.tagsTable)
def showTags(self, row, col):
for i in range(3):
print i
it = self.tagsTable.item(i, 0)
if it is None:
print "New an item at ", i, 0
it = QTableWidgetItem("tags: %d (%d,%d)" % (i, row, col))
self.tagsTable.setItem(i, 0, it)
else:
print "Existing item", i, 0
it.setText("this is a very long tags: %d (%d,%d)" % (i, row, col))
class AccountManagerDialog(QDialog):
def __init__(self, emails, types, parent):
self.emails, self.types = emails, types
QDialog.__init__(self, parent)
self.resize(560, 350)
self.gridLayout = QGridLayout(self)
self.tableWidget = QTableWidget(0, 2, self)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setSelectionBehavior(1) # Rows
self.tableWidget.setSelectionMode(1) # Single
self.tableWidget.horizontalHeader().setResizeMode(0, 1) # 1 = Stretch
self.tableWidget.setHorizontalHeaderLabels(['Email', 'Type'])
self.addBtn = QPushButton('+', self)
self.removeBtn = QPushButton('-', self)
self.closeBtn = QPushButton('Close', self)
self.spacer = QWidget(self)
self.spacer.setSizePolicy(1 | 2 | 4, 1 | 4)
self.gridLayout.addWidget(self.tableWidget, 0, 0, 1, 4)
self.gridLayout.addWidget(self.addBtn, 1, 0, 1, 1)
self.gridLayout.addWidget(self.removeBtn, 1, 1, 1, 1)
self.gridLayout.addWidget(self.spacer, 1, 2, 1, 1)
self.gridLayout.addWidget(self.closeBtn, 1, 3, 1, 1)
self.addBtn.clicked.connect(self.addAccount)
self.removeBtn.clicked.connect(self.removeAccount)
self.closeBtn.clicked.connect(self.accept)
for i in range(len(self.emails)):
self.tableWidget.insertRow(i)
self.tableWidget.setItem(i, 0, QTableWidgetItem(emails[i]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(types[i]))
def addAccount(self):
dialog = AddAccountDialog(self)
if dialog.exec_() != QDialog.Accepted: return
email = unicode(dialog.emailEdit.text())
passwd = unicode(dialog.passwordEdit.text())
ac_type = unicode(dialog.typeCombo.currentText())
self.tableWidget.insertRow(0)
self.tableWidget.setItem(0, 0, QTableWidgetItem(email))
self.tableWidget.setItem(0, 1, QTableWidgetItem(ac_type))
self.emails.insert(0, email)
self.types.insert(0, ac_type)
kr = Keyring()
kr.setPassword(email, passwd)
def removeAccount(self):
row = self.tableWidget.selectionModel().selectedRows()[0].row()
email = self.tableWidget.item(row, 0).text()
kr = Keyring()
kr.deletePassword(email)
self.tableWidget.removeRow(row)
self.emails.pop(row)
self.types.pop(row)
class SimpleListDlg(QDialog):
def __init__(self, parent = None, datalist = None, mode='r'):
super(SimpleListDlg, self).__init__(parent)
self.tbl = QTableWidget()
self.mode = mode # read only or write 'r'/'w'
self.values = []
if datalist is not None:
data = datalist.toList()
self.tbl.setRowCount(len(data))
self.tbl.setColumnCount(1)
for i,val in enumerate(data):
#print i, val.toFloat()
self.values.append(val.toFloat()[0])
it = QTableWidgetItem("%g" % val.toFloat()[0])
if self.mode == 'r':
it.setFlags(it.flags() & ~Qt.ItemIsEditable)
self.tbl.setItem(i,0,it)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|
QDialogButtonBox.Cancel)
layout = QVBoxLayout()
layout.addWidget(self.tbl)
layout.addWidget(buttonBox)
self.setLayout(layout)
self.connect(buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(buttonBox, SIGNAL("rejected()"), self.reject)
def accept(self):
self.values = []
for i in range(self.tbl.rowCount()):
v = self.tbl.item(i,0).data(Qt.EditRole).toFloat()
if self.mode == 'w': self.values.append(v[0])
self.done(0)
def reject(self):
self.values = []
self.done(0)
class SimpleListDlg(QDialog):
def __init__(self, parent = None, datalist = None, mode='r'):
super(SimpleListDlg, self).__init__(parent)
self.tbl = QTableWidget()
self.mode = mode # read only or write 'r'/'w'
self.values = []
if datalist is not None:
data = datalist.toList()
self.tbl.setRowCount(len(data))
self.tbl.setColumnCount(1)
for i,val in enumerate(data):
#print i, val.toFloat()
self.values.append(val.toFloat()[0])
it = QTableWidgetItem("%g" % val.toFloat()[0])
if self.mode == 'r':
it.setFlags(it.flags() & ~Qt.ItemIsEditable)
self.tbl.setItem(i,0,it)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|
QDialogButtonBox.Cancel)
layout = QVBoxLayout()
layout.addWidget(self.tbl)
layout.addWidget(buttonBox)
self.setLayout(layout)
self.connect(buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(buttonBox, SIGNAL("rejected()"), self.reject)
def accept(self):
self.values = []
for i in range(self.tbl.rowCount()):
v = self.tbl.item(i,0).data(Qt.EditRole).toFloat()
if self.mode == 'w': self.values.append(v[0])
self.done(0)
def reject(self):
self.values = []
self.done(0)
class phonesDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().prm
self.currLocale = self.parent().prm['currentLocale']
self.currLocale.setNumberOptions(self.currLocale.OmitGroupSeparator | self.currLocale.RejectGroupSeparator)
screen = QDesktopWidget().screenGeometry()
self.resize(screen.width()/2.5,screen.height()/3)
self.isPlaying = False
#self.audioManager = audioManager(self)
#self.playThread = threadedPlayer(self)
self.sizer = QGridLayout()
self.v1Sizer = QVBoxLayout()
self.v2Sizer = QVBoxLayout()
self.calibSizer = QGridLayout()
self.phonesTableWidget = QTableWidget()
self.phonesTableWidget.setColumnCount(4)
self.phonesTableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
self.phonesTableWidget.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.phonesTableWidget.setHorizontalHeaderLabels([self.tr('Phones'), self.tr('Max Level'), self.tr('Default'), 'id'])
self.phonesTableWidget.hideColumn(3)
self.phonesTableWidget.cellDoubleClicked[int,int].connect(self.onCellDoubleClicked)
#RENAME Phones BUTTON
self.renamePhonesButton = QPushButton(self.tr("Rename Phones"), self)
self.renamePhonesButton.clicked.connect(self.onEditLabel)
#Change Level Phones BUTTON
self.changeLevelPhonesButton = QPushButton(self.tr("Change Max Level"), self)
self.changeLevelPhonesButton.clicked.connect(self.onEditMaxLevel)
#ADD Phones BUTTON
self.addPhonesButton = QPushButton(self.tr("Add Phones"), self)
self.addPhonesButton.clicked.connect(self.onClickAddPhonesButton)
#REMOVE Phones BUTTON
self.removePhonesButton = QPushButton(self.tr("Remove Phones"), self)
self.removePhonesButton.clicked.connect(self.onClickRemovePhonesButton)
#Set Default Phones BUTTON
self.setDefaultPhonesButton = QPushButton(self.tr("Set Default"), self)
self.setDefaultPhonesButton.clicked.connect(self.onEditDefault)
self.v1Sizer.addWidget(self.renamePhonesButton)
self.v1Sizer.addWidget(self.changeLevelPhonesButton)
self.v1Sizer.addWidget(self.addPhonesButton)
self.v1Sizer.addWidget(self.removePhonesButton)
self.v1Sizer.addWidget(self.setDefaultPhonesButton)
self.v1Sizer.addStretch()
self.phonesList = {}
for i in range(len(self.prm['phones']['phonesChoices'])):
currCount = i+1
thisID = self.prm['phones']['phonesID'][i]
self.phonesList[thisID] = {}
self.phonesList[thisID]['label'] = self.prm['phones']['phonesChoices'][i]
self.phonesList[thisID]['maxLevel'] = self.prm['phones']['phonesMaxLevel'][i]
self.phonesList[thisID]['default'] = self.prm['phones']['defaultPhones'][i]
self.phonesTableWidget.setRowCount(currCount)
newItem = QTableWidgetItem(self.phonesList[thisID]['label'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount-1, 0, newItem)
newItem = QTableWidgetItem(self.currLocale.toString(self.phonesList[thisID]['maxLevel']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount-1, 1, newItem)
newItem = QTableWidgetItem(self.phonesList[thisID]['default'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount-1, 2, newItem)
self.phonesList[thisID]['qid'] = QTableWidgetItem(thisID)
self.phonesTableWidget.setItem(currCount-1, 3, self.phonesList[thisID]['qid'])
##CALIBRATION TONE
n = 0
self.calLabel = QLabel(self.tr('Calibration Tone:'), self)
self.calibSizer.addWidget(self.calLabel, n, 0, 1, 2)
n = n+1
self.toneFreqLabel = QLabel(self.tr('Frequency (Hz)'), self)
self.toneFreqTF = QLineEdit("1000")
self.toneFreqTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneFreqLabel, n, 0)
self.calibSizer.addWidget(self.toneFreqTF, n, 1)
n = n+1
self.toneLevLabel = QLabel(self.tr('Level (dB)'), self)
self.toneLevTF = QLineEdit("60")
self.toneLevTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneLevLabel, n, 0)
self.calibSizer.addWidget(self.toneLevTF, n, 1)
n = n+1
self.toneDurLabel = QLabel(self.tr('Duration (ms)'), self)
self.toneDurTF = QLineEdit("4980")
self.toneDurTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneDurLabel, n, 0)
self.calibSizer.addWidget(self.toneDurTF, n, 1)
n = n+1
self.toneRampsLabel = QLabel(self.tr('Ramps (ms)'), self)
self.toneRampsTF = QLineEdit("10")
self.toneRampsTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneRampsLabel, n, 0)
self.calibSizer.addWidget(self.toneRampsTF, n, 1)
n = n+1
self.earLabel = QLabel(self.tr('Ear:'), self)
self.earChooser = QComboBox()
self.earChooser.addItems([self.tr("Right"), self.tr("Left"), self.tr("Both")])
self.calibSizer.addWidget(self.earLabel, n, 0)
self.calibSizer.addWidget(self.earChooser, n, 1)
n = n+1
self.playCalibButton = QPushButton(self.tr("Play"), self)
self.playCalibButton.clicked.connect(self.onClickPlayCalibButton)
self.playCalibButton.setIcon(QIcon.fromTheme("media-playback-start", QIcon(":/media-playback-start")))
self.calibSizer.addWidget(self.playCalibButton, n, 0, 1, 2)
n = n+1
self.stopCalibButton = QPushButton(self.tr("Stop"), self)
self.stopCalibButton.clicked.connect(self.onClickStopCalibButton)
self.stopCalibButton.setIcon(QIcon.fromTheme("media-playback-stop", QIcon(":/media-playback-stop")))
self.calibSizer.addWidget(self.stopCalibButton, n, 0, 1, 2)
if self.prm['pref']['sound']['playCommand'] in ["alsaaudio","pyaudio"]:
self.stopCalibButton.show()
else:
self.stopCalibButton.hide()
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply|QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
buttonBox.button(QDialogButtonBox.Apply).clicked.connect(self.permanentApply)
self.sizer.addLayout(self.v1Sizer, 0, 0)
self.v2Sizer.addLayout(self.calibSizer)
self.v2Sizer.addStretch()
self.sizer.addWidget(self.phonesTableWidget, 0, 1)
self.sizer.addLayout(self.v2Sizer, 0, 2)
self.sizer.addWidget(buttonBox, 1,1,1,2)
self.sizer.setColumnStretch(1,2)
self.setLayout(self.sizer)
self.setWindowTitle(self.tr("Edit Phones"))
self.show()
def onCellDoubleClicked(self, row, col):
if col == 0:
self.onEditLabel()
elif col == 1:
self.onEditMaxLevel()
elif col == 2:
self.onEditDefault()
def onEditLabel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Only one label can be renamed at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('New name:')
text, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.phonesTableWidget.item(self.phonesList[selectedSound]['qid'].row(), 0).setText(text)
self.phonesList[selectedSound]['label'] = text
def onEditMaxLevel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('Level:')
text, ok = QInputDialog.getDouble(self, self.tr('Input Dialog'), msg, self.phonesList[selectedSound]['maxLevel'])
if ok:
self.phonesTableWidget.item(self.phonesList[selectedSound]['qid'].row(), 1).setText(self.currLocale.toString(text))
self.phonesList[selectedSound]['maxLevel'] = text
def onEditDefault(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
for i in range(self.phonesTableWidget.rowCount()):
self.phonesTableWidget.item(i, 2).setText("\u2012")
self.phonesList[str(self.phonesTableWidget.item(i, 3).text())]['default'] = "\u2012"
self.phonesTableWidget.item(self.phonesList[selectedSound]['qid'].row(), 2).setText("\u2713")
self.phonesList[selectedSound]['default'] = "\u2713"
def findSelectedItemIds(self):
selItems = self.phonesTableWidget.selectedItems()
selItemsRows = []
for i in range(len(selItems)):
selItemsRows.append(selItems[i].row())
selItemsRows = unique(selItemsRows)
selItemsIds = []
for i in range(len(selItemsRows)):
selItemsIds.append(str(self.phonesTableWidget.item(selItemsRows[i], 3).text()))
return selItemsIds
def permanentApply(self):
self.prm['phones']['phonesChoices'] = []
self.prm['phones']['phonesMaxLevel'] = []
self.prm['phones']['defaultPhones'] = []
self.prm['phones']['phonesID'] = []
keys = sorted(self.phonesList.keys())
for key in keys:
self.prm['phones']['phonesChoices'].append(str(self.phonesList[key]['label']))
self.prm['phones']['phonesMaxLevel'].append(self.phonesList[key]['maxLevel'])
self.prm['phones']['defaultPhones'].append(self.phonesList[key]['default'])
self.prm['phones']['phonesID'].append(key)
f = open(self.parent().prm['phonesPrefFile'], 'wb')
pickle.dump(self.parent().prm['phones'], f)
f.close()
for i in range(self.parent().phonesChooser.count()):
self.parent().phonesChooser.removeItem(0)
self.parent().phonesChooser.addItems(self.prm['phones']['phonesChoices'])
def onClickAddPhonesButton(self):
keys = sorted(self.phonesList.keys())
thisID = str(int(keys[-1])+1)
currCount = self.phonesTableWidget.rowCount() + 1
self.phonesList[thisID] = {}
self.phonesList[thisID]['label'] = 'Phones' + ' ' + str(currCount)
self.phonesList[thisID]['maxLevel'] = 100
self.phonesList[thisID]['default'] = "\u2012"
self.phonesTableWidget.setRowCount(currCount)
newItem = QTableWidgetItem(self.phonesList[thisID]['label'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount-1, 0, newItem)
newItem = QTableWidgetItem(self.currLocale.toString(self.phonesList[thisID]['maxLevel']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount-1, 1, newItem)
newItem = QTableWidgetItem(self.phonesList[thisID]['default'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount-1, 2, newItem)
self.phonesList[thisID]['qid'] = QTableWidgetItem(thisID)
self.phonesTableWidget.setItem(currCount-1, 3, self.phonesList[thisID]['qid'])
def onClickRemovePhonesButton(self):
if self.phonesTableWidget.rowCount() == 1:
ret = QMessageBox.warning(self, self.tr("Warning"),
self.tr("Only one phone left. Cannot remove!"),
QMessageBox.Ok)
else:
ids = self.findSelectedItemIds()
wasDefault = False
for i in range(len(ids)):
selectedPhones = ids[i]
if self.phonesTableWidget.item(self.phonesList[selectedPhones]['qid'].row(), 2).text() == "\u2713":
wasDefault = True
self.phonesTableWidget.removeRow(self.phonesList[selectedPhones]['qid'].row())
del self.phonesList[selectedPhones]
if wasDefault == True:
self.phonesTableWidget.item(0, 2).setText("\u2713")
self.phonesList[str(self.phonesTableWidget.item(0, 3).text())]['default'] = "\u2713"
def onClickPlayCalibButton(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Only one label can be renamed at a time'))
return
elif len(ids) < 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Please, select a phone in the table'))
return
else:
selectedSound = ids[0]
calMaxLev = self.phonesList[selectedSound]['maxLevel']
frequency = self.currLocale.toDouble(self.toneFreqTF.text())[0]
level = self.currLocale.toDouble(self.toneLevTF.text())[0]
duration = self.currLocale.toDouble(self.toneDurTF.text())[0]
ramp = self.currLocale.toDouble(self. toneRampsTF.text())[0]
channel = self.earChooser.currentText()
fs = self.currLocale.toInt(self.parent().sampRateTF.text())[0]
nBits = self.currLocale.toInt(self.parent().nBitsChooser.currentText())[0]
calTone = pureTone(frequency, 0, level, duration, ramp, channel, fs, calMaxLev)
self.isPlaying = True
if self.prm['pref']['sound']['playCommand'] in ["alsaaudio","pyaudio"]:
self.playThread = threadedAudioPlayer(self.parent())
else:
self.playThread = threadedExternalAudioPlayer(self.parent())
self.playThread.playThreadedSound(calTone, fs, nBits, self.prm['pref']['sound']['playCommand'], True, 'calibrationTone.wav')
if self.playThread.isFinished() == True:
self.isPlaying = False
def onClickStopCalibButton(self):
if self.isPlaying == True:
self.playThread.terminate()
#self.playThread.__del__()
def closeEvent(self, event):
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
event.accept()
def accept(self): #reimplement accept (i.e. ok button)
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
QDialog.accept(self)
def reject(self): #reimplement reject
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
QDialog.reject(self)
class ImportDataDlg(QDialog):
__isJy = False # 数据校验成功的标志
__mlist = [] # 定义一个列表用于保存从excel表中取出的数据
def __init__(self, iface, parent=None, impType=ImpDateType.SITEANDCELL):
super(ImportDataDlg, self).__init__()
self.iface = iface
self.parent = parent
self.impType = impType
self.initView()
def initView(self):
if self.impType == ImpDateType.SERVINGCELL:
self.setWindowTitle(u'相邻小区数据导入')
else:
self.setWindowTitle(u'基站和小区数据导入')
self.setWindowIcon(QIcon('images/logo.png'))
self.resize(620, 480)
# 数据表格
self.tableWidget = QTableWidget(self)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setRowCount(7)
# 设置当前Table不能编辑
self.tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
# 初始化表格上下文菜单
self.initTableContextMenu()
# 初始化表头
self.initTableHeader()
# 导入出错列表
self.listWidget = QListWidget(self)
# 按钮组
impBtn = QPushButton(u"导入EXCEL表", self)
yzBtn = QPushButton(u"数据检验", self)
impdateBtn = QPushButton(u"导入数据", self)
btnVBox = QVBoxLayout()
btnVBox.addWidget(impBtn)
btnVBox.addWidget(yzBtn)
btnVBox.addWidget(impdateBtn)
# 错误列表与按钮组
hBox = QHBoxLayout()
hBox.setMargin(20)
hBox.addWidget(self.listWidget)
hBox.addLayout(btnVBox)
self.mbar = QStatusBar(self)
self.mbar.showMessage(u'准备就绪...')
self.maction = QToolBar(self)
self.editAction = QAction(u'编辑', self.maction)
self.editAction.setCheckable(True)
self.combox = QComboBox(self)
self.combox.addItems(HeadsConfig.ImpExcelName)
self.maction.addWidget(self.combox)
self.maction.addAction(self.editAction)
vBox = QVBoxLayout()
vBox.addWidget(self.maction)
vBox.addWidget(self.tableWidget)
vBox.addLayout(hBox)
vBox.addWidget(self.mbar)
vBox.setStretchFactor(self.tableWidget, 9)
vBox.setStretchFactor(hBox, 5)
vBox.setStretchFactor(self.mbar, 1)
self.setLayout(vBox)
QObject.connect(impBtn, SIGNAL('clicked()'), self.impClick)
QObject.connect(yzBtn, SIGNAL('clicked()'), self.yzClick)
QObject.connect(impdateBtn, SIGNAL('clicked()'), self.impdateClick)
QObject.connect(self.editAction, SIGNAL('triggered()'), self.editClick)
QObject.connect(self.combox, SIGNAL('currentIndexChanged(int)'),
self.comboxChange)
self.listWidget.doubleClicked.connect(self.mlistClicked)
# self.connect(self.listWidget, SIGNAL("itemDoubleClicked (QListWidgetItem)"), self.mlistClicked)
def initTableContextMenu(self):
self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu)
self.popMenu = QMenu(self.tableWidget)
delAction = QAction(u'删除', self) # 删除
self.popMenu.addAction(delAction)
# 设置表格可以双击修改数据
def setEditTriggers(self, isTrigger):
if isTrigger:
self.tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked)
else:
self.tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
# 提供给外部修改状态栏消息
def setStatusBarMsg(self, msg):
self.mbar.showMessage(msg)
# 选框改变时，清空当前表格的全部内容，包括表格头
def updateType(self, mtype):
self.impType = mtype
self.tableWidget.clear() # 清空表格所有内容
self.initTableHeader()
# 初始化表格的每个Item
def initTable(self, mlist):
self.tableWidget.setRowCount(len(mlist))
for (i, v) in enumerate(mlist):
for (j, item) in enumerate(v):
if type(item) != str:
item = unicode(item)
if item == None:
item = u""
tabItem = QTableWidgetItem(item)
tabItem.setTextAlignment(Qt.AlignCenter)
self.tableWidget.setItem(i, j, tabItem)
# 初始化错误信息列表
def initListView(self, mlist):
for iv in mlist:
lisItm = QListWidgetItem(self.listWidget)
lisItm.setTextColor(Qt.red)
lisItm.setData(Qt.UserRole, iv)
if isinstance(iv, basestring):
# 如果错误信息是一行字符串
lisItm.setText(iv)
else:
lisItm.setText(u'第' + unicode(str(iv['row'] + 1)) + u'行，第' +
unicode(str(iv['col'] + 1)) + u'列：' + iv['msg'])
# 初始化Table的头
def initTableHeader(self):
self.heads = []
if self.impType == ImpDateType.SITEANDCELL:
# 获取当前项目图层的字段名
cell_layer = getLayerByName(u"小区", self.iface)
for head in HeadsConfig.SiteANDCellHead:
self.heads.append(head)
if len(cell_layer.pendingFields()) > 55:
for (index, field) in enumerate(cell_layer.pendingFields()):
if index > 54:
field_name = field.name().strip()
self.heads.append(field_name)
else:
self.heads = HeadsConfig.ServingCellHead
self.tableWidget.setColumnCount(len(self.heads)) # 设置表格的列数
for (i, h) in enumerate(self.heads):
tabItem = QTableWidgetItem(h)
self.tableWidget.setHorizontalHeaderItem(i, tabItem)
# 自定义为Table添加Item
def addTableItem(self, row, col, content):
tabItem = QTableWidgetItem(content)
self.tableWidget.setItem(row, col, tabItem)
# 修改Item的内容
def editTableItem(self, row, col, content):
tabItem = self.tableWidget.item(row, col)
tabItem.setText(content)
self.tableWidget.setItem(row, col, tabItem)
# 从Excel表读取数据（导入Excel表）
def impClick(self):
fileName = QFileDialog.getOpenFileName(self, u'基站小区数据导入', '/',
'Excel Files (*.xls *.xlsx)')
if fileName.strip() != "":
self.setStatusBarMsg(u'选择完毕：' + fileName)
importData = GetDataFromExcel(fileName, self.impType, self.heads)
self.__mlist = []
self.__mlist.extend(importData.getData())
self.tableWidget.clearContents()
self.listWidget.clear()
self.initTable(self.__mlist)
self.setStatusBarMsg(u'数据导入完成...')
self.__isJy = False # 导入完数据后，说明需要重新验证数据的正确性
else:
QMessageBox.information(self.parent, u"错误", u"请选中文件")
# 数据验证按钮点击事件处理
def yzClick(self):
if len(self.__mlist) > 0:
self.erlist = [] # 定义一个列表用于保存数据验证错误的数据
# 清楚全部的Item
if self.listWidget.count() > 0:
self.listWidget.clear()
# 根据tableWidget更新self.__mlist
for (r, items) in enumerate(self.__mlist):
for (v, item) in enumerate(self.__mlist[r]):
if self.tableWidget.item(r, v).text() == u"":
continue
else:
# 跟据self.__mlist[r][v]数据类型进行比对
if type(self.__mlist[r][v]) == int:
if unicode(self.__mlist[r][v]) != (
self.tableWidget.item(r, v).text()):
self.__mlist[r][v] = int(
self.tableWidget.item(r, v).text())
elif type(self.__mlist[r][v]) == float:
if unicode(self.__mlist[r][v]) != (
self.tableWidget.item(r, v).text()):
self.__mlist[r][v] = float(
self.tableWidget.item(r, v).text())
elif type(self.__mlist[r][v]) == str:
if unicode(self.__mlist[r][v]
) != self.tableWidget.item(r, v).text():
self.__mlist[r][v] = str(
self.tableWidget.item(r, v).text())
elif type(self.__mlist[r][v]) == unicode:
if (self.__mlist[r][v]) != self.tableWidget.item(
r, v).text():
self.__mlist[r][v] = self.tableWidget.item(
r, v).text()
else:
print type(self.__mlist[r][v])
# 执行数据校验函数
self.erlist = checkDataByDataType(self.__mlist, self.impType)
if len(self.erlist) > 0:
self.initListView(self.erlist)
QMessageBox.information(self.parent, u'数据校验',
u'数据校验失败，请检查数据正确性后，再导入到地图中')
self.__isJy = False
else:
QMessageBox.information(self.parent, u'数据校验', u'数据校验成功，没有错误数据')
self.__isJy = True
else:
QMessageBox.warning(self.parent, u'数据校验', u'请先导入Excel数据后再操作！')
# 导入数据到地图中
def impdateClick(self):
if self.__isJy: # 如果数据校验成功
if self.impType == ImpDateType.SITEANDCELL:
# 导入基站小区
importDataToLayer = ImportDataToLayer(self.iface, self.__mlist,
self.parent)
if importDataToLayer.importSiteAndCellData():
QMessageBox.information(self.parent, u"导入数据", u"导入数据成功！")
else:
QMessageBox.critical(self.parent, u"导入数据", u"导入数据失败！")
else:
# 导入相邻小区
importDataToLayer = ImportDataToLayer(self.iface, self.__mlist,
self.parent)
if importDataToLayer.importSCellData():
QMessageBox.information(self.parent, u"导入数据", u"导入数据成功！")
else:
QMessageBox.critical(self.parent, u"导入数据", u"导入数据失败！")
else:
QMessageBox.warning(self.parent, u'数据导入', u'请确保校验数据成功后，再导入到地图中')
# 编辑Action点击事件
def editClick(self):
self.setEditTriggers(self.editAction.isChecked())
# 错误列表双击事件处理
def mlistClicked(self, listItem):
itemData = listItem.data(Qt.UserRole)
self.tableWidget.setFocus()
self.tableWidget.setCurrentCell(itemData['row'], itemData['col'])
# 选框改变事件
def comboxChange(self, index):
self.updateType(index)
# 字段验证是否为空
def __validNull(self, name, col, row, itm, rowitm):
if itm is None or itm == '':
tmpMap = {}
tmpMap['col'] = col
tmpMap['row'] = row
tmpMap['msg'] = unicode(name) + u'不能为空'
tmpMap['item'] = rowitm
return tmpMap
else:
return None
# 导入数据线程开始信号 绑定函数
def impStart(self):
self.setStatusBarMsg(u'准备导入...')
# 导入数据线程发生异常信号 绑定函数
def impError(self, e, exception_string):
self.setStatusBarMsg(u'发生错误：' + unicode(e))
QMessageBox.warning(self.parent, u'Excel数据导入', u'发生错误：' + unicode(e))
# 导入数据线程完成信号 绑定函数
def impFinish(self, mylist):
self.__mlist = []
self.__mlist.extend(mylist)
self.mthread.quit()
self.mthread.wait()
self.mthread.deleteLater()
self.impDateThread.deleteLater()
self.tableWidget.clearContents()
self.listWidget.clear()
self.initTable(self.__mlist)
self.setStatusBarMsg(u'数据导入完成...')
self.__isJy = False # 导入完数据后，说明需要重新验证数据的正确性
# 导入数据到地图线程发生异常信号 绑定函数
def impError1(self, e, exception_string):
self.setStatusBarMsg(u"导入数据发生错误")
QMessageBox.critical(self, u'数据导入', u"发生错误：" + unicode(e))
# 导入数据到地图线程完成信号 绑定函数
def impFinish1(self, mylist):
self.threadImp.quit()
self.threadImp.wait()
self.threadImp.deleteLater()
self.impFeatureThread.deleteLater()
remsg = u'数据导入完成！'
layer = None
if self.impType == LayerType.SITE:
# remsg = u'基站' + remsg
layer = getLayerByName(u'基站', self.iface)
elif self.impType == LayerType.CELL:
# remsg = u'小区' + remsg
layer = getLayerByName(u'小区', self.iface)
else:
remsg = u'相邻小区' + remsg
layer = getLayerByName(u'相邻小区', self.iface)
self.setStatusBarMsg(remsg)
layer.updateExtents() # 更新地图数据
self.iface.actionDraw().trigger()
QMessageBox.information(self, u'数据导入', remsg)
merlist = []
for eritm in self.erlist:
merlist.append(eritm['item'])
self.tableWidget.clearContents() # 先清楚表格的内容，再将错误的行显示到表格中
self.initTable(merlist)
class Main(plugin.Plugin):
" Main Class "
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.scriptPath, self.scriptArgs = "", []
self.profilerPath, self.tempPath = profilerPath, tempPath
self.output = " ERROR: FAIL: No output ! "
self.process = QProcess()
self.process.finished.connect(self.on_process_finished)
self.process.error.connect(self.on_process_error)
self.tabWidget, self.stat = QTabWidget(), QWidget()
self.tabWidget.tabCloseRequested.connect(
lambda: self.tabWidget.setTabPosition(1) if self.tabWidget.
tabPosition() == 0 else self.tabWidget.setTabPosition(0))
self.tabWidget.setStyleSheet('QTabBar{font-weight:bold;}')
self.tabWidget.setMovable(True)
self.tabWidget.setTabsClosable(True)
self.vboxlayout1 = QVBoxLayout(self.stat)
self.hboxlayout1 = QHBoxLayout()
self.filterTableLabel = QLabel("<b>Type to Search : </b>", self.stat)
self.hboxlayout1.addWidget(self.filterTableLabel)
self.filterTableLineEdit = QLineEdit(self.stat)
self.filterTableLineEdit.setPlaceholderText(' Type to Search . . . ')
self.hboxlayout1.addWidget(self.filterTableLineEdit)
self.filterHintTableLabel = QLabel(" ? ", self.stat)
self.hboxlayout1.addWidget(self.filterHintTableLabel)
self.vboxlayout1.addLayout(self.hboxlayout1)
self.tableWidget = QTableWidget(self.stat)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setColumnCount(8)
self.tableWidget.setRowCount(2)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(5, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(6, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(7, item)
self.tableWidget.itemDoubleClicked.connect(
self.on_tableWidget_itemDoubleClicked)
self.vboxlayout1.addWidget(self.tableWidget)
self.tabWidget.addTab(self.stat, " ? ")
self.source = QWidget()
self.gridlayout = QGridLayout(self.source)
self.scintillaWarningLabel = QLabel(
"QScintilla is not installed!. Falling back to basic text edit!.",
self.source)
self.gridlayout.addWidget(self.scintillaWarningLabel, 1, 0, 1, 2)
self.sourceTreeWidget = QTreeWidget(self.source)
self.sourceTreeWidget.setAlternatingRowColors(True)
self.sourceTreeWidget.itemActivated.connect(
self.on_sourceTreeWidget_itemActivated)
self.sourceTreeWidget.itemClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.sourceTreeWidget.itemDoubleClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.gridlayout.addWidget(self.sourceTreeWidget, 0, 0, 1, 1)
self.sourceTextEdit = QTextEdit(self.source)
self.sourceTextEdit.setReadOnly(True)
self.gridlayout.addWidget(self.sourceTextEdit, 0, 1, 1, 1)
self.tabWidget.addTab(self.source, " ? ")
self.result = QWidget()
self.vlayout = QVBoxLayout(self.result)
self.globalStatGroupBox = QGroupBox(self.result)
self.hboxlayout = QHBoxLayout(self.globalStatGroupBox)
self.totalTimeLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.totalTimeLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.totalTimeLcdNumber.setNumDigits(7)
self.totalTimeLcdNumber.display(1000000)
self.totalTimeLcdNumber.setFrameShape(QFrame.StyledPanel)
self.totalTimeLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.totalTimeLcdNumber)
self.tTimeLabel = QLabel("<b>Total Time (Sec)</b>",
self.globalStatGroupBox)
self.tTimeLabel.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.tTimeLabel)
self.numCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.numCallLcdNumber.setNumDigits(7)
self.numCallLcdNumber.display(1000000)
self.numCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.numCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.numCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.numCallLcdNumber)
self.numCallLabel = QLabel("<b>Number of calls</b>",
self.globalStatGroupBox)
self.numCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.numCallLabel)
self.primCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.primCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.primCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.primCallLcdNumber.setNumDigits(7)
self.primCallLcdNumber.display(1000000)
self.primCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.primCallLcdNumber)
self.primCallLabel = QLabel("<b>Primitive calls (%)</b>",
self.globalStatGroupBox)
self.primCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.primCallLabel)
self.vlayout.addWidget(self.globalStatGroupBox)
try:
from PyKDE4.kdeui import KRatingWidget
self.rating = KRatingWidget(self.globalStatGroupBox)
self.rating.setToolTip('Profiling Performance Rating')
except ImportError:
pass
self.tabWidget.addTab(self.result, " Get Results ! ")
self.resgraph = QWidget()
self.vlayout2 = QVBoxLayout(self.result)
self.graphz = QGroupBox(self.resgraph)
self.hboxlayout2 = QHBoxLayout(self.graphz)
try:
from PyKDE4.kdeui import KLed
KLed(self.graphz)
except ImportError:
pass
self.hboxlayout2.addWidget(
QLabel('''
Work in Progress :) Not Ready Yet'''))
self.vlayout2.addWidget(self.graphz)
self.tabWidget.addTab(self.resgraph, " Graphs and Charts ")
self.pathz = QWidget()
self.vlayout3 = QVBoxLayout(self.pathz)
self.patz = QGroupBox(self.pathz)
self.hboxlayout3 = QVBoxLayout(self.patz)
self.profilepath = QLineEdit(profilerPath)
self.getprofile = QPushButton(QIcon.fromTheme("document-open"), 'Open')
self.getprofile.setToolTip(
'Dont touch if you dont know what are doing')
self.getprofile.clicked.connect(lambda: self.profilepath.setText(
str(
QFileDialog.getOpenFileName(
self.patz, ' Open the profile.py file ',
path.expanduser("~"), ';;(profile.py)'))))
self.hboxlayout3.addWidget(
QLabel(
'<center><b>Profile.py Python Library Full Path:</b></center>')
)
self.hboxlayout3.addWidget(self.profilepath)
self.hboxlayout3.addWidget(self.getprofile)
self.argGroupBox = QGroupBox(self.pathz)
self.hbxlayout = QHBoxLayout(self.argGroupBox)
self.argLineEdit = QLineEdit(self.argGroupBox)
self.argLineEdit.setToolTip(
'Not touch if you dont know what are doing')
self.argLineEdit.setPlaceholderText(
'Dont touch if you dont know what are doing')
self.hbxlayout.addWidget(
QLabel('<b>Additional Profile Arguments:</b>'))
self.hbxlayout.addWidget(self.argLineEdit)
self.hboxlayout3.addWidget(self.argGroupBox)
self.vlayout3.addWidget(self.patz)
self.tabWidget.addTab(self.pathz, " Paths and Configs ")
self.outp = QWidget()
self.vlayout4 = QVBoxLayout(self.outp)
self.outgro = QGroupBox(self.outp)
self.outgro.setTitle(" MultiProcessing Output Logs ")
self.hboxlayout4 = QVBoxLayout(self.outgro)
self.outputlog = QTextEdit()
self.outputlog.setText('''
I do not fear computers, I fear the lack of them. -Isaac Asimov ''')
self.hboxlayout4.addWidget(self.outputlog)
self.vlayout4.addWidget(self.outgro)
self.tabWidget.addTab(self.outp, " Logs ")
self.actionNew_profiling = QAction(QIcon.fromTheme("document-new"),
'New Profiling', self)
self.actionLoad_profile = QAction(QIcon.fromTheme("document-open"),
'Open Profiling', self)
self.actionClean = QAction(QIcon.fromTheme("edit-clear"), 'Clean',
self)
self.actionClean.triggered.connect(lambda: self.clearContent)
self.actionAbout = QAction(QIcon.fromTheme("help-about"), 'About',
self)
self.actionAbout.triggered.connect(lambda: QMessageBox.about(
self.dock, __doc__, ', '.join(
(__doc__, __license__, __author__, __email__))))
self.actionSave_profile = QAction(QIcon.fromTheme("document-save"),
'Save Profiling', self)
self.actionManual = QAction(QIcon.fromTheme("help-contents"), 'Help',
self)
self.actionManual.triggered.connect(lambda: open_new_tab(
'http://docs.python.org/library/profile.html'))
self.tabWidget.setCurrentIndex(2)
self.globalStatGroupBox.setTitle("Global Statistics")
item = self.tableWidget.horizontalHeaderItem(0)
item.setText("Number of Calls")
item = self.tableWidget.horizontalHeaderItem(1)
item.setText("Total Time")
item = self.tableWidget.horizontalHeaderItem(2)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(3)
item.setText("Cumulative Time")
item = self.tableWidget.horizontalHeaderItem(4)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(5)
item.setText("Filename")
item = self.tableWidget.horizontalHeaderItem(6)
item.setText("Line")
item = self.tableWidget.horizontalHeaderItem(7)
item.setText("Function")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.stat),
"Statistics per Function")
self.sourceTreeWidget.headerItem().setText(0, "Source files")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.source),
"Sources Navigator")
#######################################################################
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(self.tabWidget)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
QToolBar(self.dock).addActions(
(self.actionNew_profiling, self.actionClean,
self.actionSave_profile, self.actionLoad_profile,
self.actionManual, self.actionAbout))
self.actionNew_profiling.triggered.connect(
self.on_actionNew_profiling_triggered)
self.actionLoad_profile.triggered.connect(
self.on_actionLoad_profile_triggered)
self.actionSave_profile.triggered.connect(
self.on_actionSave_profile_triggered)
self.locator.get_service('misc').add_widget(
self.dock, QIcon.fromTheme("document-open-recent"), __doc__)
if QSCI:
# Scintilla source editor management
self.scintillaWarningLabel.setText(' QScintilla is Ready ! ')
layout = self.source.layout()
layout.removeWidget(self.sourceTextEdit)
self.sourceTextEdit = Qsci.QsciScintilla(self.source)
layout.addWidget(self.sourceTextEdit, 0, 1)
doc = self.sourceTextEdit
doc.setLexer(Qsci.QsciLexerPython(self.sourceTextEdit))
doc.setReadOnly(True)
doc.setEdgeMode(Qsci.QsciScintilla.EdgeLine)
doc.setEdgeColumn(80)
doc.setEdgeColor(QColor("#FF0000"))
doc.setFolding(Qsci.QsciScintilla.BoxedTreeFoldStyle)
doc.setBraceMatching(Qsci.QsciScintilla.SloppyBraceMatch)
doc.setCaretLineVisible(True)
doc.setMarginLineNumbers(1, True)
doc.setMarginWidth(1, 25)
doc.setTabWidth(4)
doc.setEolMode(Qsci.QsciScintilla.EolUnix)
self.marker = {}
for color in COLORS:
mnr = doc.markerDefine(Qsci.QsciScintilla.Background)
doc.setMarkerBackgroundColor(color, mnr)
self.marker[color] = mnr
self.currentSourcePath = None
# Connect table and tree filter edit signal to unique slot
self.filterTableLineEdit.textEdited.connect(
self.on_filterLineEdit_textEdited)
# Timer to display filter hint message
self.filterHintTimer = QTimer(self)
self.filterHintTimer.setSingleShot(True)
self.filterHintTimer.timeout.connect(self.on_filterHintTimer_timeout)
# Timer to start search
self.filterSearchTimer = QTimer(self)
self.filterSearchTimer.setSingleShot(True)
self.filterSearchTimer.timeout.connect(
self.on_filterSearchTimer_timeout)
self.tabLoaded = {}
for i in range(10):
self.tabLoaded[i] = False
self.backgroundTreeMatchedItems = {}
self.resizeWidgetToContent(self.tableWidget)
def on_actionNew_profiling_triggered(self):
self.clearContent()
self.scriptPath = str(
QFileDialog.getOpenFileName(self.dock,
"Choose your script to profile",
path.expanduser("~"),
"Python (*.py *.pyw)"))
commandLine = [
self.profilerPath, "-o", self.tempPath, self.scriptPath
] + self.scriptArgs
commandLine = " ".join(commandLine)
##if self.termCheckBox.checkState() == Qt.Checked:
#termList = ["xterm", "aterm"]
#for term in termList:
#termPath = which(term)
#if termPath:
#break
#commandLine = """%s -e "%s ; echo 'Press ENTER Exit' ; read" """ \
#% (termPath, commandLine)
self.process.start(commandLine)
if not self.process.waitForStarted():
print((" ERROR: {} failed!".format(commandLine)))
return
def on_process_finished(self, exitStatus):
' whan the process end '
print((" INFO: OK: QProcess is %s" % self.process.exitCode()))
self.output = self.process.readAll().data()
if not self.output:
self.output = " ERROR: FAIL: No output ! "
self.outputlog.setText(self.output + str(self.process.exitCode()))
if path.exists(self.tempPath):
self.setStat(self.tempPath)
remove(self.tempPath)
else:
self.outputlog.setText(" ERROR: QProcess FAIL: Profiling failed.")
self.tabWidget.setCurrentIndex(2)
def on_process_error(self, error):
' when the process fail, I hope you never see this '
print(" ERROR: QProcess FAIL: Profiler Dead, wheres your God now ? ")
if error == QProcess.FailedToStart:
self.outputlog.setText(" ERROR: FAIL: Profiler execution failed ")
elif error == QProcess.Crashed:
self.outputlog.setText(" ERROR: FAIL: Profiler execution crashed ")
else:
self.outputlog.setText(" ERROR: FAIL: Profiler unknown error ")
def on_actionLoad_profile_triggered(self):
"""Load a previous profile sessions"""
statPath = str(
QFileDialog.getOpenFileName(self.dock, "Open profile dump",
path.expanduser("~"),
"Profile file (*)"))
if statPath:
self.clearContent()
print(' INFO: OK: Loading profiling from ' + statPath)
self.setStat(statPath)
def on_actionSave_profile_triggered(self):
"""Save a profile sessions"""
statPath = str(
QFileDialog.getSaveFileName(self.dock, "Save profile dump",
path.expanduser("~"),
"Profile file (*)"))
if statPath:
#TODO: handle error case and give feelback to user
print(' INFO: OK: Saving profiling to ' + statPath)
self.stat.save(statPath)
#=======================================================================#
# Common parts #
#=======================================================================#
def on_tabWidget_currentChanged(self, index):
"""slot for tab change"""
# Kill search and hint timer if running to avoid cross effect
for timer in (self.filterHintTimer, self.filterSearchTimer):
if timer.isActive():
timer.stop()
if not self.stat:
#No stat loaded, nothing to do
return
self.populateTable()
self.populateSource()
def on_filterLineEdit_textEdited(self, text):
"""slot for filter change (table or tree"""
if self.filterSearchTimer.isActive():
# Already runnning, stop it
self.filterSearchTimer.stop()
# Start timer
self.filterSearchTimer.start(300)
def on_filterHintTimer_timeout(self):
"""Timeout to warn user about text length"""
print("timeout")
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
label = self.filterHintTableLabel
label.setText("Type > 2 characters to search")
def on_filterSearchTimer_timeout(self):
"""timeout to start search"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
text = self.filterTableLineEdit.text()
label = self.filterHintTableLabel
edit = self.filterTableLineEdit
widget = self.tableWidget
else:
print("Unknow tab for filterSearch timeout !")
print(("do search for %s" % text))
if not len(text):
# Empty keyword, just clean all
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
self.warnUSer(True, edit)
self.clearSearch()
return
if len(text) < 2:
# Don't filter if text is too short and tell it to user
self.filterHintTimer.start(600)
return
else:
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
# Search
self.clearSearch()
matchedItems = []
if tab == TAB_FUNCTIONSTAT:
# Find items
matchedItems = widget.findItems(text, Qt.MatchContains)
widget.setSortingEnabled(False)
matchedRows = [item.row() for item in matchedItems]
# Hide matched items
header = widget.verticalHeader()
for row in range(widget.rowCount()):
if row not in matchedRows:
header.hideSection(row)
widget.setSortingEnabled(True)
else:
print(" Unknow tab for filterSearch timeout ! ")
print(("got %s members" % len(matchedItems)))
self.warnUSer(matchedItems, edit)
self.resizeWidgetToContent(widget)
def resizeWidgetToContent(self, widget):
"""Resize all columns according to content"""
for i in range(widget.columnCount()):
widget.resizeColumnToContents(i)
def clearSearch(self):
"""Clean search result
For table, show all items
For tree, remove colored items"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
header = self.tableWidget.verticalHeader()
if header.hiddenSectionCount():
for i in range(header.count()):
if header.isSectionHidden(i):
header.showSection(i)
def clearContent(self):
# Clear tabs
self.tableWidget.clearContents()
self.sourceTreeWidget.clear()
# Reset LCD numbers
for lcdNumber in (self.totalTimeLcdNumber, self.numCallLcdNumber,
self.primCallLcdNumber):
lcdNumber.display(1000000)
# Reset stat
self.pstat = None
# Disable save as menu
self.actionSave_profile.setEnabled(False)
# Mark all tabs as unloaded
for i in range(10):
self.tabLoaded[i] = False
def warnUSer(self, result, inputWidget):
palette = inputWidget.palette()
if result:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 255, 255))
else:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 136, 138))
inputWidget.setPalette(palette)
inputWidget.update()
def setStat(self, statPath):
self.stat = Stat(path=statPath)
# Global stat update
self.totalTimeLcdNumber.display(self.stat.getTotalTime())
self.numCallLcdNumber.display(self.stat.getCallNumber())
self.primCallLcdNumber.display(self.stat.getPrimitiveCallRatio())
# Refresh current tab
self.on_tabWidget_currentChanged(self.tabWidget.currentIndex())
# Activate save as menu
self.actionSave_profile.setEnabled(True)
try:
self.rating.setMaxRating(10)
self.rating.setRating(
int(self.stat.getPrimitiveCallRatio()) / 10 - 1)
except:
pass
#========================================================================#
# Statistics table #
#=======================================================================#
def populateTable(self):
row = 0
rowCount = self.stat.getStatNumber()
progress = QProgressDialog("Populating statistics table...", "Abort",
0, 2 * rowCount)
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setRowCount(rowCount)
progress.setWindowModality(Qt.WindowModal)
for (key, value) in self.stat.getStatItems():
#ncalls
item = StatTableWidgetItem(str(value[0]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_NCALLS, item)
colorTableItem(item, self.stat.getCallNumber(), value[0])
#total time
item = StatTableWidgetItem(str(value[2]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[2])
#per call (total time)
if value[0] != 0:
tPerCall = str(value[2] / value[0])
cPerCall = str(value[3] / value[0])
else:
tPerCall = ""
cPerCall = ""
item = StatTableWidgetItem(tPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TPERCALL, item)
colorTableItem(
item,
100.0 * self.stat.getTotalTime() / self.stat.getCallNumber(),
tPerCall)
#per call (cumulative time)
item = StatTableWidgetItem(cPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CPERCALL, item)
colorTableItem(
item,
100.0 * self.stat.getTotalTime() / self.stat.getCallNumber(),
cPerCall)
#cumulative time
item = StatTableWidgetItem(str(value[3]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[3])
#Filename
self.tableWidget.setItem(row, STAT_FILENAME,
StatTableWidgetItem(str(key[0])))
#Line
item = StatTableWidgetItem(str(key[1]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_LINE, item)
#Function name
self.tableWidget.setItem(row, STAT_FUNCTION,
StatTableWidgetItem(str(key[2])))
row += 1
# Store it in stat hash array
self.stat.setStatLink(item, key, TAB_FUNCTIONSTAT)
progress.setValue(row)
if progress.wasCanceled():
return
for i in range(self.tableWidget.rowCount()):
progress.setValue(row + i)
for j in range(self.tableWidget.columnCount()):
item = self.tableWidget.item(i, j)
if item:
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setSortingEnabled(True)
self.resizeWidgetToContent(self.tableWidget)
progress.setValue(2 * rowCount)
def on_tableWidget_itemDoubleClicked(self, item):
matchedItems = []
filename = str(self.tableWidget.item(item.row(), STAT_FILENAME).text())
if not filename or filename.startswith("<"):
# No source code associated, return immediatly
return
function = self.tableWidget.item(item.row(), STAT_FUNCTION).text()
line = self.tableWidget.item(item.row(), STAT_LINE).text()
self.on_tabWidget_currentChanged(TAB_SOURCE) # load source tab
function = "%s (%s)" % (function, line)
fathers = self.sourceTreeWidget.findItems(filename, Qt.MatchContains,
SOURCE_FILENAME)
print(("find %s father" % len(fathers)))
for father in fathers:
findItems(father, function, SOURCE_FILENAME, matchedItems)
print(("find %s items" % len(matchedItems)))
if matchedItems:
self.tabWidget.setCurrentIndex(TAB_SOURCE)
self.sourceTreeWidget.scrollToItem(matchedItems[0])
self.on_sourceTreeWidget_itemClicked(matchedItems[0],
SOURCE_FILENAME)
matchedItems[0].setSelected(True)
else:
print("oups, item found but cannot scroll to it !")
#=======================================================================#
# Source explorer #
#=====================================================================#
def populateSource(self):
items = {}
for stat in self.stat.getStatKeys():
source = stat[0]
function = "%s (%s)" % (stat[2], stat[1])
if source in ("", "profile") or source.startswith("<"):
continue
# Create the function child
child = QTreeWidgetItem([function])
# Store it in stat hash array
self.stat.setStatLink(child, stat, TAB_SOURCE)
if source in items:
father = items[source]
else:
# Create the father
father = QTreeWidgetItem([source])
items[source] = father
father.addChild(child)
self.sourceTreeWidget.setSortingEnabled(False)
for value in list(items.values()):
self.sourceTreeWidget.addTopLevelItem(value)
self.sourceTreeWidget.setSortingEnabled(True)
def on_sourceTreeWidget_itemActivated(self, item, column):
self.on_sourceTreeWidget_itemClicked(item, column)
def on_sourceTreeWidget_itemClicked(self, item, column):
line = 0
parent = item.parent()
if QSCI:
doc = self.sourceTextEdit
if parent:
pathz = parent.text(column)
result = match("(.*) \(([0-9]+)\)", item.text(column))
if result:
try:
function = str(result.group(1))
line = int(result.group(2))
except ValueError:
# We got garbage... falling back to line 0
pass
else:
pathz = item.text(column)
pathz = path.abspath(str(pathz))
if self.currentSourcePath != pathz:
# Need to load source
self.currentSourcePath == pathz
try:
if QSCI:
doc.clear()
doc.insert(file(pathz).read())
else:
self.sourceTextEdit.setPlainText(file(pathz).read())
except IOError:
QMessageBox.warning(self, "Error",
"Source file could not be found",
QMessageBox.Ok)
return
if QSCI:
for function, line in [(i[2], i[1])
for i in self.stat.getStatKeys()
if i[0] == pathz]:
# expr, regexp, case sensitive, whole word, wrap, forward
doc.findFirst("def", False, True, True, False, True, line,
0, True)
end, foo = doc.getCursorPosition()
time = self.stat.getStatTotalTime((pathz, line, function))
colorSource(doc, self.stat.getTotalTime(), time, line, end,
self.marker)
if QSCI:
doc.ensureLineVisible(line)
class wavListDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().parent().prm
self.audioManager = audioManager(self)
self.currLocale = self.parent().parent().prm['currentLocale']
self.currLocale.setNumberOptions(self.currLocale.OmitGroupSeparator | self.currLocale.RejectGroupSeparator)
self.isPlaying = False
self.sizer = QGridLayout()
self.v1Sizer = QVBoxLayout()
self.wavsTableWidget = QTableWidget()
self.wavsTableWidget.setColumnCount(4)
self.wavsTableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
self.wavsTableWidget.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.wavsTableWidget.setHorizontalHeaderLabels([self.tr("File"), self.tr('Use'), self.tr("RMS Level"), 'id'])
self.quidColumn = 3
self.wavsTableWidget.hideColumn(self.quidColumn)
self.wavsTableWidget.cellDoubleClicked[int,int].connect(self.onCellDoubleClicked)
#ADD wav BUTTON
self.addWavButton = QPushButton(self.tr("Add Wav"), self)
self.addWavButton.clicked.connect(self.onClickAddWavButton)
#REMOVE wav BUTTON
self.removeWavButton = QPushButton(self.tr("Remove Wav"), self)
self.removeWavButton.clicked.connect(self.onClickRemoveWavButton)
#PLAY wav BUTTON
self.playWavButton = QPushButton(self.tr("Play Wav"), self)
self.playWavButton.clicked.connect(self.onClickPlayWavButton)
#STOP wav BUTTON
self.stopWavButton = QPushButton(self.tr("Stop Playing"), self)
self.stopWavButton.clicked.connect(self.onClickStopWavButton)
self.v1Sizer.addWidget(self.addWavButton)
self.v1Sizer.addWidget(self.removeWavButton)
self.v1Sizer.addWidget(self.playWavButton)
self.v1Sizer.addWidget(self.stopWavButton)
self.v1Sizer.addStretch()
self.wavsList = {}
for i in range(len(self.parent().wavsPref['endMessageFiles'])):
currCount = i+1
thisID = self.parent().wavsPref['endMessageFilesID'][i]
self.wavsList[thisID] = {}
self.wavsList[thisID]['file'] = self.parent().wavsPref['endMessageFiles'][i]
self.wavsList[thisID]['use'] = self.parent().wavsPref['endMessageFilesUse'][i]
self.wavsList[thisID]['level'] = self.parent().wavsPref['endMessageLevels'][i]
self.wavsTableWidget.setRowCount(currCount)
n = 0
newItem = QTableWidgetItem(self.wavsList[thisID]['file'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount-1, n, newItem)
n = n+1
newItem = QTableWidgetItem(self.wavsList[thisID]['use'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount-1, n, newItem)
n = n+1
newItem = QTableWidgetItem(self.currLocale.toString(self.wavsList[thisID]['level']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount-1, n, newItem)
n = n+1
self.wavsList[thisID]['qid'] = QTableWidgetItem(thisID)
self.wavsTableWidget.setItem(currCount-1, n, self.wavsList[thisID]['qid'])
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply|QDialogButtonBox.Ok|QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
self.sizer.addLayout(self.v1Sizer, 0, 0)
self.sizer.addWidget(self.wavsTableWidget,0,1)
self.sizer.addWidget(buttonBox, 1,1)
self.setLayout(self.sizer)
self.setWindowTitle(self.tr("Edit Wavs"))
self.show()
def onCellDoubleClicked(self, row, col):
if col == 0:
pass
elif col == 1:
self.onEditUse()
elif col == 2:
self.onEditLevel()
def onEditLevel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('RMS Level:')
text, ok = QInputDialog.getDouble(self, self.tr('Input Dialog'), msg, self.wavsList[selectedSound]['level'])
if ok:
self.wavsTableWidget.item(self.wavsList[selectedSound]['qid'].row(), 2).setText(self.currLocale.toString(text))
self.wavsList[selectedSound]['level'] = text
def onEditUse(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
if self.wavsTableWidget.item(self.wavsList[selectedSound]['qid'].row(), 1).text() == "\u2012":
self.wavsTableWidget.item(self.wavsList[selectedSound]['qid'].row(), 1).setText("\u2713")
self.wavsList[selectedSound]['use'] = "\u2713"
else:
self.wavsTableWidget.item(self.wavsList[selectedSound]['qid'].row(), 1).setText("\u2012")
self.wavsList[selectedSound]['use'] = "\u2012"
def findSelectedItemIds(self):
selItems = self.wavsTableWidget.selectedItems()
selItemsRows = []
for i in range(len(selItems)):
selItemsRows.append(selItems[i].row())
selItemsRows = unique(selItemsRows)
selItemsIds = []
for i in range(len(selItemsRows)):
selItemsIds.append(str(self.wavsTableWidget.item(selItemsRows[i], self.quidColumn).text()))
return selItemsIds
def permanentApply(self):
self.wavListToPass = {}
self.wavListToPass['endMessageFiles'] = []
self.wavListToPass['endMessageFilesUse'] = []
self.wavListToPass['endMessageFilesID'] = []
self.wavListToPass['endMessageLevels'] = []
keys = sorted(self.wavsList.keys())
for key in keys:
self.wavListToPass['endMessageFiles'].append(str(self.wavsList[key]['file']))
self.wavListToPass['endMessageFilesUse'].append(self.wavsList[key]['use'])
self.wavListToPass['endMessageLevels'].append(self.wavsList[key]['level'])
self.wavListToPass['endMessageFilesID'].append(key)
def onClickAddWavButton(self):
fName = QFileDialog.getOpenFileName(self, self.tr("Choose wav file to load"), '', self.tr("wav files (*.wav);;All Files (*)"))[0]
if len(fName) > 0: #if the user didn't press cancel
if len(self.wavsList.keys()) > 0:
keys = sorted(self.wavsList.keys())
thisID = str(int(keys[-1])+1)
else:
thisID = "1"
currCount = self.wavsTableWidget.rowCount() + 1
self.wavsList[thisID] = {}
self.wavsList[thisID]['file'] = fName
self.wavsList[thisID]['use'] = "\u2713"
self.wavsList[thisID]['level'] = 60
self.wavsTableWidget.setRowCount(currCount)
n = 0
newItem = QTableWidgetItem(self.wavsList[thisID]['file'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount-1, n, newItem)
n = n+1
newItem = QTableWidgetItem(self.wavsList[thisID]['use'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount-1, n, newItem)
n = n+1
newItem = QTableWidgetItem(self.currLocale.toString(self.wavsList[thisID]['level']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount-1, n, newItem)
n = n+1
self.wavsList[thisID]['qid'] = QTableWidgetItem(thisID)
self.wavsTableWidget.setItem(currCount-1, n, self.wavsList[thisID]['qid'])
def onClickRemoveWavButton(self):
ids = self.findSelectedItemIds()
for i in range(len(ids)):
selectedWavs = ids[i]
self.wavsTableWidget.removeRow(self.wavsList[selectedWavs]['qid'].row())
del self.wavsList[selectedWavs]
def onClickPlayWavButton(self):
ids = self.findSelectedItemIds()
if len(ids) < 1:
QMessageBox.warning(self, self.tr('Warning'), self.tr('No files selected for playing'))
else:
if len(ids) > 1:
pass #maybe say on the status bar that only the first one will be played
selectedWav = ids[0]
fName = self.wavsList[selectedWav]['file']
level = self.wavsList[selectedWav]['level']
nBits = self.currLocale.toInt(self.parent().parent().nBitsChooser.currentText())[0]
maxLevel = float(self.prm['phones']['phonesMaxLevel'][self.parent().parent().phonesChooser.currentIndex()])
msgSnd, fs = self.audioManager.loadWavFile(fName, level, maxLevel, 'Both')
self.isPlaying = True
if self.prm['pref']['sound']['playCommand'] in ["alsaaudio","pyaudio"]:
self.playThread = threadedAudioPlayer(self.parent().parent())
else:
self.playThread = threadedExternalAudioPlayer(self.parent().parent())
self.playThread.playThreadedSound(msgSnd, fs, nBits, self.prm['pref']['sound']['playCommand'], False, 'tmp.wav')
if self.playThread.isFinished == True:
self.isPlaying = False
def onClickStopWavButton(self):
if self.isPlaying == True:
self.playThread.terminate()
def closeEvent(self, event):
if self.isPlaying == True:
self.playThread.terminate()
event.accept()
def accept(self): #reimplement accept (i.e. ok button)
if self.isPlaying == True:
self.playThread.terminate()
QDialog.accept(self)
def reject(self): #reimplement reject
if self.isPlaying == True:
self.playThread.terminate()
QDialog.reject(self)
class Previewer(QMainWindow):
"""Provide a display of a sequence, reminiscent
of DExTer main view.
"""
def __init__(self, tr=translate(), precision=4):
super().__init__()
self.p = precision + 1 # number of s.f. for floating points
self.tr = tr
self.init_UI()
self.set_sequence()
def reset_table(self, table, digital=1):
"""Set empty table items in all of the cells of the
given table. The items are not editable.
digital -- 1: Set the background colour red
-- 0: Set the text as ''."""
for i in range(table.rowCount()):
for j in range(table.columnCount()):
item = QTableWidgetItem()
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
table.setItem(i, j, item)
if digital:
table.item(i, j).setBackground(Qt.red)
else:
table.item(i, j).setText('')
def init_UI(self):
"""Create all of the widget objects required"""
self.centre_widget = QWidget()
self.tabs = QTabWidget() # make tabs for each main display
self.centre_widget.layout = QVBoxLayout()
self.centre_widget.layout.addWidget(self.tabs)
self.centre_widget.setLayout(self.centre_widget.layout)
self.setCentralWidget(self.centre_widget)
num_e = len(self.tr.seq_dic['Event list array in'])
num_s = len(self.tr.seq_dic['Experimental sequence cluster in']
['Sequence header top'])
menubar = self.menuBar()
# save/load a sequence file
menubar.clear(
) # prevents recreating menubar if init_UI() is called again
seq_menu = menubar.addMenu('Sequence')
load = QAction('Load Sequence', self)
load.triggered.connect(self.load_seq_from_file)
seq_menu.addAction(load)
save = QAction('Save Sequence', self)
save.triggered.connect(self.save_seq_file)
seq_menu.addAction(save)
#### tab for previewing sequences ####
preview_tab = QWidget()
prv_layout = QVBoxLayout()
preview_tab.setLayout(prv_layout)
scroll_widget = QWidget()
prv_layout.addWidget(scroll_widget)
prv_vbox = QVBoxLayout()
scroll_widget.setLayout(prv_vbox)
self.tabs.addTab(preview_tab, "Sequence")
# position the widgets on the layout:
# metadata
self.routine_name = QLabel('', self)
self.routine_desc = QLabel('', self)
for label, name in [[self.routine_name, 'Routine name: '],
[self.routine_desc, 'Routine description: ']]:
layout = QHBoxLayout()
title = QLabel(name, self)
title.setFixedWidth(200)
layout.addWidget(title)
label.setStyleSheet('border: 1px solid black')
label.setFixedWidth(400)
layout.addWidget(label)
prv_vbox.addLayout(layout)
# list of event descriptions
self.e_list = QTableWidget(4, num_e)
self.e_list.setVerticalHeaderLabels([
'Event name: ', 'Routine specific event? ', 'Event indices: ',
'Event path: '
])
self.e_list.setFixedHeight(150)
self.reset_table(self.e_list, 0)
prv_vbox.addWidget(self.e_list)
# event header top
self.head_top = QTableWidget(14, num_s)
self.head_top.setVerticalHeaderLabels([
'Skip Step: ', 'Event name: ', 'Hide event steps: ', 'Event ID: ',
'Time step name: ', 'Populate multirun: ', 'Time step length: ',
'Time unit: ', 'D/A trigger: ', 'Trigger this time step? ',
'Channel: ', 'Analogue voltage (V): ', 'GPIB event name: ',
'GPIB on/off? '
])
self.head_top.setFixedHeight(450)
self.reset_table(self.head_top, 0)
prv_vbox.addWidget(self.head_top)
# fast digital channels
fd_head = QLabel('Fast Digital', self)
prv_vbox.addWidget(fd_head)
self.fd_chans = QTableWidget(self.tr.nfd, num_s)
self.fd_chans.setFixedHeight(400)
self.reset_table(self.fd_chans, 1)
prv_vbox.addWidget(self.fd_chans)
# fast analogue channels
fa_head = QLabel('Fast Analogue', self)
prv_vbox.addWidget(fa_head)
self.fa_chans = QTableWidget(self.tr.nfa, num_s * 2)
self.fa_chans.setFixedHeight(260)
self.reset_table(self.fa_chans, 0)
prv_vbox.addWidget(self.fa_chans)
# event header middle
self.head_mid = QTableWidget(14, num_s)
self.head_mid.setVerticalHeaderLabels([
'Skip Step: ', 'Event name: ', 'Hide event steps: ', 'Event ID: ',
'Time step name: ', 'Populate multirun: ', 'Time step length: ',
'Time unit: ', 'D/A trigger: ', 'Trigger this time step? ',
'Channel: ', 'Analogue voltage (V): ', 'GPIB event name: ',
'GPIB on/off? '
])
self.head_mid.setFixedHeight(450)
self.reset_table(self.head_mid, 0)
prv_vbox.addWidget(self.head_mid)
# slow digital channels
sd_head = QLabel('Slow Digital', self)
prv_vbox.addWidget(sd_head)
self.sd_chans = QTableWidget(self.tr.nsd, num_s)
self.sd_chans.setFixedHeight(400)
self.reset_table(self.sd_chans, 1)
prv_vbox.addWidget(self.sd_chans)
# slow analogue channels
sa_head = QLabel('Slow Analogue', self)
prv_vbox.addWidget(sa_head)
self.sa_chans = QTableWidget(self.tr.nsa, num_s * 2)
self.sa_chans.setFixedHeight(400)
self.reset_table(self.sa_chans, 0)
prv_vbox.addWidget(self.sa_chans)
# place scroll bars if the contents of the window are too large
scroll = QScrollArea(self)
scroll.setWidget(scroll_widget)
scroll.setWidgetResizable(True)
scroll.setFixedHeight(800)
prv_layout.addWidget(scroll)
#### tab for multi-run settings ####
self.mr = multirun_widget(self.tr)
self.tabs.addTab(self.mr, "Multirun")
mr_menu = menubar.addMenu('Multirun')
mrload = QAction('Load Parameters', self)
mrload.triggered.connect(self.mr.load_mr_params)
mr_menu.addAction(mrload)
mrsave = QAction('Save Parameters', self)
mrsave.triggered.connect(self.mr.save_mr_params)
mr_menu.addAction(mrsave)
mrqueue = QAction('View Queue', self)
mrqueue.triggered.connect(self.mr.view_mr_queue)
mr_menu.addAction(mrqueue)
# choose main window position and dimensions: (xpos,ypos,width,height)
self.setWindowTitle('Multirun Editor and Sequence Preview')
self.setWindowIcon(QIcon('docs/previewicon.png'))
def reset_UI(self):
"""After loading in a new sequence, adjust the UI
so that the tables have the right number of rows and columns. """
num_e = len(self.tr.seq_dic['Event list array in'])
num_s = len(self.tr.seq_dic['Experimental sequence cluster in']
['Sequence header top'])
for table, rows, cols, dig in [
[self.e_list, 4, num_e, 0], [self.head_top, 14, num_s, 0],
[self.fd_chans, self.tr.nfd, num_s, 1],
[self.fa_chans, self.tr.nfa, num_s * 2, 0],
[self.head_mid, 14, num_s, 0],
[self.sd_chans, self.tr.nsd, num_s, 1],
[self.sa_chans, self.tr.nsa, num_s * 2, 0]
]:
table.setRowCount(rows)
table.setColumnCount(cols)
self.reset_table(table, dig)
self.mr.reset_sequence(self.tr)
def try_browse(self,
title='Select a File',
file_type='all (*)',
open_func=QFileDialog.getOpenFileName):
"""Open a file dialog and retrieve a file name from the browser.
title: String to display at the top of the file browser window
default_path: directory to open first
file_type: types of files that can be selected
open_func: the function to use to open the file browser"""
try:
if 'PyQt4' in sys.modules:
file_name = open_func(self, title, '', file_type)
elif 'PyQt5' in sys.modules:
file_name, _ = open_func(self, title, '', file_type)
return file_name
except OSError:
return '' # probably user cancelled
def load_seq_from_file(self, fname=''):
"""Choose a file name, load the sequence and then show it in the previewer."""
if not fname: fname = self.try_browse(file_type='XML (*.xml);;all (*)')
if fname:
try:
self.tr.load_xml(fname)
self.reset_UI()
self.set_sequence()
except TypeError as e:
logger.error("Tried to load invalid sequence")
def save_seq_file(self, fname=''):
"""Save the current sequence to an xml file."""
if not fname:
fname = self.try_browse(title='Choose a file name',
file_type='XML (*.xml);;all (*)',
open_func=QFileDialog.getSaveFileName)
if fname:
self.tr.write_to_file(fname)
def set_sequence(self):
"""Fill the labels with the values from the sequence"""
seq = self.tr.seq_dic
self.routine_name.setText(seq['Routine name in'])
self.routine_desc.setText(seq['Routine description in'])
ela = seq['Event list array in'] # shorthand
esc = seq['Experimental sequence cluster in']
self.fd_chans.setVerticalHeaderLabels(
map(str.__add__, esc['Fast digital names']['Hardware ID'], [
': ' + name if name else ''
for name in esc['Fast digital names']['Name']
]))
self.fa_chans.setVerticalHeaderLabels(
map(str.__add__, esc['Fast analogue names']['Hardware ID'], [
': ' + name if name else ''
for name in esc['Fast analogue names']['Name']
]))
self.sd_chans.setVerticalHeaderLabels(
map(str.__add__, esc['Slow digital names']['Hardware ID'], [
': ' + name if name else ''
for name in esc['Slow digital names']['Name']
]))
self.sa_chans.setVerticalHeaderLabels(
map(str.__add__, esc['Slow analogue names']['Hardware ID'], [
': ' + name if name else ''
for name in esc['Slow analogue names']['Name']
]))
for i in range(len(ela)):
self.e_list.item(0, i).setText(ela[i]['Event name'])
self.e_list.item(1,
i).setText(str(ela[i]['Routine specific event?']))
self.e_list.item(2, i).setText(','.join(
map(str, ela[i]['Event indices'])))
self.e_list.item(3, i).setText(ela[i]['Event path'])
for i in range(len(esc['Sequence header top'])):
for j, key in enumerate([
'Skip Step', 'Event name', 'Hide event steps', 'Event ID',
'Time step name', 'Populate multirun', 'Time step length',
'Time unit', 'Digital or analogue trigger?',
'Trigger this time step?', 'Channel',
'Analogue voltage (V)', 'GPIB event name', 'GPIB on/off?'
]):
if key == 'Time step length' or key == 'Analogue voltage (V)':
self.head_top.item(j, i).setText(
fmt(esc['Sequence header top'][i][key],
self.p)) # to 'p' s.f.
self.head_mid.item(j, i).setText(
fmt(esc['Sequence header middle'][i][key], self.p))
else:
self.head_top.item(j, i).setText(
str(esc['Sequence header top'][i][key]))
self.head_mid.item(j, i).setText(
str(esc['Sequence header middle'][i][key]))
self.fd_chans.setHorizontalHeaderLabels(
[h['Time step name'] for h in esc['Sequence header top']])
for j in range(self.tr.nfd):
self.fd_chans.item(j, i).setBackground(Qt.green if BOOL(
esc['Fast digital channels'][i][j]) else Qt.red)
self.fa_chans.setHorizontalHeaderLabels([
h['Time step name'] for h in esc['Sequence header top']
for j in range(2)
])
for j in range(self.tr.nfa):
self.fa_chans.item(j, 2 * i).setText(
fmt(esc['Fast analogue array'][j]['Voltage'][i], self.p))
self.fa_chans.item(j, 2 * i + 1).setText('Ramp' if BOOL(
esc['Fast analogue array'][j]['Ramp?'][i]) else '')
self.sd_chans.setHorizontalHeaderLabels(
[h['Time step name'] for h in esc['Sequence header middle']])
for j in range(self.tr.nsd):
self.sd_chans.item(j, i).setBackground(Qt.green if BOOL(
esc['Slow digital channels'][i][j]) else Qt.red)
self.sa_chans.setHorizontalHeaderLabels([
h['Time step name'] for h in esc['Sequence header middle']
for j in range(2)
])
for j in range(self.tr.nsa):
self.sa_chans.item(j, 2 * i).setText(
fmt(esc['Slow analogue array'][j]['Voltage'][i], self.p))
self.sa_chans.item(j, 2 * i + 1).setText('Ramp' if BOOL(
esc['Slow analogue array'][j]['Ramp?'][i]) else '')
def choose_multirun_dir(self):
"""Allow the user to choose the directory where the histogram .csv
files and the measure .dat file will be saved as part of the multi-run"""
try:
dir_path = QFileDialog.getExistingDirectory(
self, "Select Directory", '')
self.multirun_save_dir.setText(dir_path)
except OSError:
pass # user cancelled - file not found
class UpdateDialog(QDialog):
def __init__(self, update_script):
super(UpdateDialog, self).__init__(None, Qt.Window)
self.updates_to_run = []
self.setWindowTitle("emzed updates")
self.setWindowModality(Qt.WindowModal)
self.setMinimumWidth(600)
self.update_script = update_script
self.setup_widgets()
self.setup_layout()
self.connect_signals()
wd = QApplication.desktop().width()
hd = QApplication.desktop().height()
w = self.size().width()
h = self.size().height()
self.move((wd - w) / 2, (hd - h) / 2)
def showEvent(self, evt):
self.setCursor(Qt.WaitCursor)
class WorkerThread(QThread):
def run(self, script=self.update_script, parent=self):
try:
for method, args in script(parent.add_info_line, parent.add_update_info):
self.emit(SIGNAL("execute_method(PyQt_PyObject, PyQt_PyObject)"), method, args)
except:
import traceback
tb = traceback.format_exc()
self.emit(SIGNAL("execute_method(PyQt_PyObject, PyQt_PyObject)"), parent.add_info_line, (tb,))
self.emit(SIGNAL("update_query_finished()"))
self.t = WorkerThread()
self.connect(self.t, SIGNAL("update_query_finished()"), self.start_to_interact)
self.connect(
self.t, SIGNAL("execute_method(PyQt_PyObject,PyQt_PyObject)"), self.execute_method)
try:
self.t.start()
finally:
self.setCursor(Qt.ArrowCursor)
def execute_method(self, meth, args):
meth(*args)
def start_to_interact(self):
self.ok_button.setEnabled(True)
def setup_widgets(self):
self.label_info = QLabel("updates from exchange folder:")
self.info = QTextEdit(self)
self.info.setReadOnly(1)
self.label_updates = QLabel("updates from internet:")
self.updates = QTableWidget(0, 3)
self.updates.setHorizontalHeaderLabels(["updater", "info", "try updatde ?"])
self.updates.verticalHeader().hide()
self.updates.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.updates.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.ok_button = QPushButton("OK")
self.ok_button.setEnabled(False)
def setup_layout(self):
layout = QVBoxLayout()
self.setLayout(layout)
layout.addWidget(self.label_info)
layout.addWidget(self.info)
layout.addWidget(self.label_updates)
layout.addWidget(self.updates)
button_layout = QHBoxLayout()
button_layout.addStretch()
button_layout.addWidget(self.ok_button)
layout.addLayout(button_layout)
def connect_signals(self):
self.connect(self.ok_button, SIGNAL("pressed()"), self.accept)
def ok_button_pressed(self):
self.info.append("hi")
self.add_update_info("updater", "info")
def _item(self, content, is_checkable):
item = QTableWidgetItem(str(content))
if is_checkable:
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsSelectable)
return item
def add_update_info(self, updater_id, info, with_checkbox=True):
i = self.updates.rowCount()
self.updates.insertRow(i)
self.updates.setItem(i, 0, self._item(updater_id, False))
self.updates.setItem(i, 1, self._item(info, False))
if True or with_checkbox:
self.updates.setItem(i, 2, self._item("", True))
def add_info_line(self, txt):
self.info.append(txt)
def get_updates_to_run(self):
return self.updates_to_run
def accept(self):
for i in range(self.updates.rowCount()):
updater_id = str(self.updates.item(i, 0).text())
item = self.updates.item(i, 2)
if item is not None: # some cells in column are empty
checked = self.updates.item(i, 2).checkState() == Qt.Checked
if checked:
self.updates_to_run.append(updater_id)
super(UpdateDialog, self).accept()
class SpreadSheet(QMainWindow):
dateFormats = ["dd/M/yyyy", "yyyy/M/dd", "dd.MM.yyyy"]
currentDateFormat = dateFormats[0]
def __init__(self, rows, cols, parent = None):
super(SpreadSheet, self).__init__(parent)
self.toolBar = QToolBar()
self.addToolBar(self.toolBar)
self.formulaInput = QLineEdit()
self.cellLabel = QLabel(self.toolBar)
self.cellLabel.setMinimumSize(80, 0)
self.toolBar.addWidget(self.cellLabel)
self.toolBar.addWidget(self.formulaInput)
self.table = QTableWidget(rows, cols, self)
for c in range(cols):
character = chr(ord('A') + c)
self.table.setHorizontalHeaderItem(c, QTableWidgetItem(character))
self.table.setItemPrototype(self.table.item(rows - 1, cols - 1))
self.table.setItemDelegate(SpreadSheetDelegate(self))
self.createActions()
self.updateColor(0)
self.setupMenuBar()
self.setupContents()
self.setupContextMenu()
self.setCentralWidget(self.table)
self.statusBar()
self.table.currentItemChanged.connect(self.updateStatus)
self.table.currentItemChanged.connect(self.updateColor)
self.table.currentItemChanged.connect(self.updateLineEdit)
self.table.itemChanged.connect(self.updateStatus)
self.formulaInput.returnPressed.connect(self.returnPressed)
self.table.itemChanged.connect(self.updateLineEdit)
self.setWindowTitle("Spreadsheet")
def createActions(self):
self.cell_sumAction = QAction("Sum", self)
self.cell_sumAction.triggered.connect(self.actionSum)
self.cell_addAction = QAction("&Add", self)
self.cell_addAction.setShortcut(Qt.CTRL | Qt.Key_Plus)
self.cell_addAction.triggered.connect(self.actionAdd)
self.cell_subAction = QAction("&Subtract", self)
self.cell_subAction.setShortcut(Qt.CTRL | Qt.Key_Minus)
self.cell_subAction.triggered.connect(self.actionSubtract)
self.cell_mulAction = QAction("&Multiply", self)
self.cell_mulAction.setShortcut(Qt.CTRL | Qt.Key_multiply)
self.cell_mulAction.triggered.connect(self.actionMultiply)
self.cell_divAction = QAction("&Divide", self)
self.cell_divAction.setShortcut(Qt.CTRL | Qt.Key_division)
self.cell_divAction.triggered.connect(self.actionDivide)
self.fontAction = QAction("Font...", self)
self.fontAction.setShortcut(Qt.CTRL | Qt.Key_F)
self.fontAction.triggered.connect(self.selectFont)
self.colorAction = QAction(QIcon(QPixmap(16, 16)), "Background &Color...", self)
self.colorAction.triggered.connect(self.selectColor)
self.clearAction = QAction("Clear", self)
self.clearAction.setShortcut(Qt.Key_Delete)
self.clearAction.triggered.connect(self.clear)
self.aboutSpreadSheet = QAction("About Spreadsheet", self)
self.aboutSpreadSheet.triggered.connect(self.showAbout)
self.exitAction = QAction("E&xit", self)
self.exitAction.setShortcut(QKeySequence.Quit)
self.exitAction.triggered.connect(QApplication.instance().quit)
self.printAction = QAction("&Print", self)
self.printAction.setShortcut(QKeySequence.Print)
self.printAction.triggered.connect(self.print_)
self.firstSeparator = QAction(self)
self.firstSeparator.setSeparator(True)
self.secondSeparator = QAction(self)
self.secondSeparator.setSeparator(True)
def setupMenuBar(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.dateFormatMenu = self.fileMenu.addMenu("&Date format")
self.dateFormatGroup = QActionGroup(self)
for f in self.dateFormats:
action = QAction(f, self, checkable=True,
triggered=self.changeDateFormat)
self.dateFormatGroup.addAction(action)
self.dateFormatMenu.addAction(action)
if f == self.currentDateFormat:
action.setChecked(True)
self.fileMenu.addAction(self.printAction)
self.fileMenu.addAction(self.exitAction)
self.cellMenu = self.menuBar().addMenu("&Cell")
self.cellMenu.addAction(self.cell_addAction)
self.cellMenu.addAction(self.cell_subAction)
self.cellMenu.addAction(self.cell_mulAction)
self.cellMenu.addAction(self.cell_divAction)
self.cellMenu.addAction(self.cell_sumAction)
self.cellMenu.addSeparator()
self.cellMenu.addAction(self.colorAction)
self.cellMenu.addAction(self.fontAction)
self.menuBar().addSeparator()
self.aboutMenu = self.menuBar().addMenu("&Help")
self.aboutMenu.addAction(self.aboutSpreadSheet)
def changeDateFormat(self):
action = self.sender()
oldFormat = self.currentDateFormat
newFormat = self.currentDateFormat = action.text()
for row in range(self.table.rowCount()):
item = self.table.item(row, 1)
date = QDate.fromString(item.text(), oldFormat)
item.setText(date.toString(newFormat))
def updateStatus(self, item):
if item and item == self.table.currentItem():
self.statusBar().showMessage(item.data(Qt.StatusTipRole).toString(), 1000)
self.cellLabel.setText("Cell: (%s)" % encode_pos(self.table.row(item),
self.table.column(item)))
def updateColor(self, item):
pixmap = QPixmap(16, 16)
color = QColor()
if item:
color = item.backgroundColor()
if not color.isValid():
color = self.palette().base().color()
painter = QPainter(pixmap)
painter.fillRect(0, 0, 16, 16, color)
lighter = color.lighter()
painter.setPen(lighter)
# light frame
painter.drawPolyline(QPoint(0, 15), QPoint(0, 0), QPoint(15, 0))
painter.setPen(color.darker())
# dark frame
painter.drawPolyline(QPoint(1, 15), QPoint(15, 15), QPoint(15, 1))
painter.end()
self.colorAction.setIcon(QIcon(pixmap))
def updateLineEdit(self, item):
if item != self.table.currentItem():
return
if item:
self.formulaInput.setText(item.data(Qt.EditRole).toString())
else:
self.formulaInput.clear()
def returnPressed(self):
text = self.formulaInput.text()
row = self.table.currentRow()
col = self.table.currentColumn()
item = self.table.item(row, col)
if not item:
self.table.setItem(row, col, SpreadSheetItem(text))
else:
item.setData(Qt.EditRole, text)
self.table.viewport().update()
def selectColor(self):
item = self.table.currentItem()
color = item and QColor(item.background()) or self.table.palette().base().color()
color = QColorDialog.getColor(color, self)
if not color.isValid():
return
selected = self.table.selectedItems()
if not selected:
return
for i in selected:
i and i.setBackground(color)
self.updateColor(self.table.currentItem())
def selectFont(self):
selected = self.table.selectedItems()
if not selected:
return
font, ok = QFontDialog.getFont(self.font(), self)
if not ok:
return
for i in selected:
i and i.setFont(font)
def runInputDialog(self, title, c1Text, c2Text, opText,
outText, cell1, cell2, outCell):
rows = []
cols = []
for r in range(self.table.rowCount()):
rows.append(str(r + 1))
for c in range(self.table.columnCount()):
cols.append(chr(ord('A') + c))
addDialog = QDialog(self)
addDialog.setWindowTitle(title)
group = QGroupBox(title, addDialog)
group.setMinimumSize(250, 100)
cell1Label = QLabel(c1Text, group)
cell1RowInput = QComboBox(group)
c1Row, c1Col = decode_pos(cell1)
cell1RowInput.addItems(rows)
cell1RowInput.setCurrentIndex(c1Row)
cell1ColInput = QComboBox(group)
cell1ColInput.addItems(cols)
cell1ColInput.setCurrentIndex(c1Col)
operatorLabel = QLabel(opText, group)
operatorLabel.setAlignment(Qt.AlignHCenter)
cell2Label = QLabel(c2Text, group)
cell2RowInput = QComboBox(group)
c2Row, c2Col = decode_pos(cell2)
cell2RowInput.addItems(rows)
cell2RowInput.setCurrentIndex(c2Row)
cell2ColInput = QComboBox(group)
cell2ColInput.addItems(cols)
cell2ColInput.setCurrentIndex(c2Col)
equalsLabel = QLabel("=", group)
equalsLabel.setAlignment(Qt.AlignHCenter)
outLabel = QLabel(outText, group)
outRowInput = QComboBox(group)
outRow, outCol = decode_pos(outCell)
outRowInput.addItems(rows)
outRowInput.setCurrentIndex(outRow)
outColInput = QComboBox(group)
outColInput.addItems(cols)
outColInput.setCurrentIndex(outCol)
cancelButton = QPushButton("Cancel", addDialog)
cancelButton.clicked.connect(addDialog.reject)
okButton = QPushButton("OK", addDialog)
okButton.setDefault(True)
okButton.clicked.connect(addDialog.accept)
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch(1)
buttonsLayout.addWidget(okButton)
buttonsLayout.addSpacing(10)
buttonsLayout.addWidget(cancelButton)
dialogLayout = QVBoxLayout(addDialog)
dialogLayout.addWidget(group)
dialogLayout.addStretch(1)
dialogLayout.addItem(buttonsLayout)
cell1Layout = QHBoxLayout()
cell1Layout.addWidget(cell1Label)
cell1Layout.addSpacing(10)
cell1Layout.addWidget(cell1ColInput)
cell1Layout.addSpacing(10)
cell1Layout.addWidget(cell1RowInput)
cell2Layout = QHBoxLayout()
cell2Layout.addWidget(cell2Label)
cell2Layout.addSpacing(10)
cell2Layout.addWidget(cell2ColInput)
cell2Layout.addSpacing(10)
cell2Layout.addWidget(cell2RowInput)
outLayout = QHBoxLayout()
outLayout.addWidget(outLabel)
outLayout.addSpacing(10)
outLayout.addWidget(outColInput)
outLayout.addSpacing(10)
outLayout.addWidget(outRowInput)
vLayout = QVBoxLayout(group)
vLayout.addItem(cell1Layout)
vLayout.addWidget(operatorLabel)
vLayout.addItem(cell2Layout)
vLayout.addWidget(equalsLabel)
vLayout.addStretch(1)
vLayout.addItem(outLayout)
if addDialog.exec_():
cell1 = cell1ColInput.currentText() + cell1RowInput.currentText()
cell2 = cell2ColInput.currentText() + cell2RowInput.currentText()
outCell = outColInput.currentText() + outRowInput.currentText()
return True, cell1, cell2, outCell
return False, None, None, None
def actionSum(self):
row_first = 0
row_last = 0
row_cur = 0
col_first = 0
col_last = 0
col_cur = 0
selected = self.table.selectedItems()
if selected:
first = selected[0]
last = selected[-1]
row_first = self.table.row(first)
row_last = self.table.row(last)
col_first = self.table.column(first)
col_last = self.table.column(last)
current = self.table.currentItem()
if current:
row_cur = self.table.row(current)
col_cur = self.table.column(current)
cell1 = encode_pos(row_first, col_first)
cell2 = encode_pos(row_last, col_last)
out = encode_pos(row_cur, col_cur)
ok, cell1, cell2, out = self.runInputDialog("Sum cells", "First cell:",
"Last cell:", u"\N{GREEK CAPITAL LETTER SIGMA}", "Output to:",
cell1, cell2, out)
if ok:
row, col = decode_pos(out)
self.table.item(row, col).setText("sum %s %s" % (cell1, cell2))
def actionMath_helper(self, title, op):
cell1 = "C1"
cell2 = "C2"
out = "C3"
current = self.table.currentItem()
if current:
out = encode_pos(self.table.currentRow(), self.table.currentColumn())
ok, cell1, cell2, out = self.runInputDialog(title, "Cell 1", "Cell 2",
op, "Output to:", cell1, cell2, out)
if ok:
row, col = decode_pos(out)
self.table.item(row, col).setText("%s %s %s" % (op, cell1, cell2))
def actionAdd(self):
self.actionMath_helper("Addition", "+")
def actionSubtract(self):
self.actionMath_helper("Subtraction", "-")
def actionMultiply(self):
self.actionMath_helper("Multiplication", "*")
def actionDivide(self):
self.actionMath_helper("Division", "/")
def clear(self):
for i in self.table.selectedItems():
i.setText("")
def setupContextMenu(self):
self.addAction(self.cell_addAction)
self.addAction(self.cell_subAction)
self.addAction(self.cell_mulAction)
self.addAction(self.cell_divAction)
self.addAction(self.cell_sumAction)
self.addAction(self.firstSeparator)
self.addAction(self.colorAction)
self.addAction(self.fontAction)
self.addAction(self.secondSeparator)
self.addAction(self.clearAction)
self.setContextMenuPolicy(Qt.ActionsContextMenu)
def setupContents(self):
titleBackground = QColor(Qt.lightGray)
titleFont = self.table.font()
titleFont.setBold(True)
# column 0
self.table.setItem(0, 0, SpreadSheetItem("Item"))
self.table.item(0, 0).setBackground(titleBackground)
self.table.item(0, 0).setToolTip("This column shows the purchased item/service")
self.table.item(0, 0).setFont(titleFont)
self.table.setItem(1, 0, SpreadSheetItem("AirportBus"))
self.table.setItem(2, 0, SpreadSheetItem("Flight (Munich)"))
self.table.setItem(3, 0, SpreadSheetItem("Lunch"))
self.table.setItem(4, 0, SpreadSheetItem("Flight (LA)"))
self.table.setItem(5, 0, SpreadSheetItem("Taxi"))
self.table.setItem(6, 0, SpreadSheetItem("Dinner"))
self.table.setItem(7, 0, SpreadSheetItem("Hotel"))
self.table.setItem(8, 0, SpreadSheetItem("Flight (Oslo)"))
self.table.setItem(9, 0, SpreadSheetItem("Total:"))
self.table.item(9, 0).setFont(titleFont)
self.table.item(9, 0).setBackground(Qt.lightGray)
# column 1
self.table.setItem(0, 1, SpreadSheetItem("Date"))
self.table.item(0, 1).setBackground(titleBackground)
self.table.item(0, 1).setToolTip("This column shows the purchase date, double click to change")
self.table.item(0, 1).setFont(titleFont)
self.table.setItem(1, 1, SpreadSheetItem("15/6/2006"))
self.table.setItem(2, 1, SpreadSheetItem("15/6/2006"))
self.table.setItem(3, 1, SpreadSheetItem("15/6/2006"))
self.table.setItem(4, 1, SpreadSheetItem("21/5/2006"))
self.table.setItem(5, 1, SpreadSheetItem("16/6/2006"))
self.table.setItem(6, 1, SpreadSheetItem("16/6/2006"))
self.table.setItem(7, 1, SpreadSheetItem("16/6/2006"))
self.table.setItem(8, 1, SpreadSheetItem("18/6/2006"))
self.table.setItem(9, 1, SpreadSheetItem())
self.table.item(9, 1).setBackground(Qt.lightGray)
# column 2
self.table.setItem(0, 2, SpreadSheetItem("Price"))
self.table.item(0, 2).setBackground(titleBackground)
self.table.item(0, 2).setToolTip("This column shows the price of the purchase")
self.table.item(0, 2).setFont(titleFont)
self.table.setItem(1, 2, SpreadSheetItem("150"))
self.table.setItem(2, 2, SpreadSheetItem("2350"))
self.table.setItem(3, 2, SpreadSheetItem("-14"))
self.table.setItem(4, 2, SpreadSheetItem("980"))
self.table.setItem(5, 2, SpreadSheetItem("5"))
self.table.setItem(6, 2, SpreadSheetItem("120"))
self.table.setItem(7, 2, SpreadSheetItem("300"))
self.table.setItem(8, 2, SpreadSheetItem("1240"))
self.table.setItem(9, 2, SpreadSheetItem())
self.table.item(9, 2).setBackground(Qt.lightGray)
# column 3
self.table.setItem(0, 3, SpreadSheetItem("Currency"))
self.table.item(0, 3).setBackgroundColor(titleBackground)
self.table.item(0, 3).setToolTip("This column shows the currency")
self.table.item(0, 3).setFont(titleFont)
self.table.setItem(1, 3, SpreadSheetItem("NOK"))
self.table.setItem(2, 3, SpreadSheetItem("NOK"))
self.table.setItem(3, 3, SpreadSheetItem("EUR"))
self.table.setItem(4, 3, SpreadSheetItem("EUR"))
self.table.setItem(5, 3, SpreadSheetItem("USD"))
self.table.setItem(6, 3, SpreadSheetItem("USD"))
self.table.setItem(7, 3, SpreadSheetItem("USD"))
self.table.setItem(8, 3, SpreadSheetItem("USD"))
self.table.setItem(9, 3, SpreadSheetItem())
self.table.item(9,3).setBackground(Qt.lightGray)
# column 4
self.table.setItem(0, 4, SpreadSheetItem("Ex. Rate"))
self.table.item(0, 4).setBackground(titleBackground)
self.table.item(0, 4).setToolTip("This column shows the exchange rate to NOK")
self.table.item(0, 4).setFont(titleFont)
self.table.setItem(1, 4, SpreadSheetItem("1"))
self.table.setItem(2, 4, SpreadSheetItem("1"))
self.table.setItem(3, 4, SpreadSheetItem("8"))
self.table.setItem(4, 4, SpreadSheetItem("8"))
self.table.setItem(5, 4, SpreadSheetItem("7"))
self.table.setItem(6, 4, SpreadSheetItem("7"))
self.table.setItem(7, 4, SpreadSheetItem("7"))
self.table.setItem(8, 4, SpreadSheetItem("7"))
self.table.setItem(9, 4, SpreadSheetItem())
self.table.item(9,4).setBackground(Qt.lightGray)
# column 5
self.table.setItem(0, 5, SpreadSheetItem("NOK"))
self.table.item(0, 5).setBackground(titleBackground)
self.table.item(0, 5).setToolTip("This column shows the expenses in NOK")
self.table.item(0, 5).setFont(titleFont)
self.table.setItem(1, 5, SpreadSheetItem("* C2 E2"))
self.table.setItem(2, 5, SpreadSheetItem("* C3 E3"))
self.table.setItem(3, 5, SpreadSheetItem("* C4 E4"))
self.table.setItem(4, 5, SpreadSheetItem("* C5 E5"))
self.table.setItem(5, 5, SpreadSheetItem("* C6 E6"))
self.table.setItem(6, 5, SpreadSheetItem("* C7 E7"))
self.table.setItem(7, 5, SpreadSheetItem("* C8 E8"))
self.table.setItem(8, 5, SpreadSheetItem("* C9 E9"))
self.table.setItem(9, 5, SpreadSheetItem("sum F2 F9"))
self.table.item(9,5).setBackground(Qt.lightGray)
def showAbout(self):
QMessageBox.about(self, "About Spreadsheet", """
<HTML>
<p><b>This demo shows use of <c>QTableWidget</c> with custom handling for
individual cells.</b></p>
<p>Using a customized table item we make it possible to have dynamic
output in different cells. The content that is implemented for this
particular demo is:
<ul>
<li>Adding two cells.</li>
<li>Subtracting one cell from another.</li>
<li>Multiplying two cells.</li>
<li>Dividing one cell with another.</li>
<li>Summing the contents of an arbitrary number of cells.</li>
</HTML>
""")
def print_(self):
pass
class UserDialog(QDialog):
holdc = {}
def __init__(self, parent=None):
super(UserDialog, self).__init__(parent)
self.pagetitle = self.sessionname
self.tableFont = QFont('Century Gothic', 8)
self.table = QTableWidget()
self.cols = [
'SN', 'ITEM', 'QUANTITY', 'UNIT AMOUNT', 'TOTAL AMOUNT', 'DATE'
]
self.h1_pull_box = QVBoxLayout()
#self.tableFont.setFamily('Century Gothic')
self.tableHeaderStyle = "::section {" "background-color: teal; color:white}"
#pull all CA
self.editID = 0
self.hold_unit = {}
self.hold_store = {}
self.hold_storeGroup = {}
self.hold_borrowed = {}
from_label = QLabel('From:')
to_label = QLabel('To:')
self.fromData = QDateEdit()
self.toData = QDateEdit()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.fromData.setCalendarPopup(True)
self.toData.setDate(currentDate.currentDate())
self.toData.setCalendarPopup(True)
menu = QMenu()
menu.addAction('All', lambda: self.reloadTable(0))
menu.addAction('In-Stock', lambda: self.reloadTable(1))
menu.addAction('Out-Stock', lambda: self.reloadTable(2))
menu.addAction('Damaged', lambda: self.reloadTable(3))
menu.addAction('Borrowed', lambda: self.reloadTable(4))
self.pull_btn = QPushButton()
self.pull_btn.setText("Load")
self.pull_btn.setMenu(menu)
h_pull_box = QHBoxLayout()
h_pull_box.addWidget(from_label)
h_pull_box.addWidget(self.fromData)
h_pull_box.addWidget(to_label)
h_pull_box.addWidget(self.toData)
h_pull_box.addWidget(self.pull_btn)
storeGroup = self.pullGroupStore()
unit = self.pullUnit()
self.storeGroupText = QLabel('Category')
self.storeGroupData = QComboBox()
self.storeGroupData.currentIndexChanged.connect(self.reloadStore)
self.storeText = QLabel('Items')
self.storeData = QComboBox()
self.amountText = QLabel('Total Cost')
self.amountData = QLineEdit()
self.amountData.setPlaceholderText('0000.00')
self.tellerText = QLabel('Reciept No.')
self.tellerData = QLineEdit()
self.tellerData.setPlaceholderText('xxxxxxxxx')
self.quantityText = QLabel('Quantity.')
self.quantityData = QLineEdit()
self.quantityData.setPlaceholderText('00.0')
self.periodText = QLabel('Period (days)')
self.periodData = QLineEdit()
self.periodData.setPlaceholderText('00.0')
self.personText = QLabel('Recieved By:')
self.personData = QLineEdit()
self.personData.setPlaceholderText('00.0')
self.unitText = QLabel('Unit')
self.unitData = QComboBox()
self.borrowedText = QLabel('Borrowed')
self.borrowedData = QComboBox()
self.dateText = QLabel('Date')
self.dateData = QDateEdit()
self.dateData.setDate(currentDate.currentDate())
self.dateData.setCalendarPopup(True)
self.descriptionText = QLabel('Description')
self.descriptionData = QPlainTextEdit()
self.descriptionData.move(200, 100)
self.borrowedText.hide()
self.borrowedData.hide()
mboz = QVBoxLayout()
hboz = QHBoxLayout()
self.state = QLabel('')
self.r1 = QRadioButton('In-stock')
self.r1.setChecked(True)
self.r1.toggled.connect(lambda: self.changeStates())
self.r2 = QRadioButton('Out-stock')
self.r2.toggled.connect(lambda: self.changeStates())
self.r3 = QRadioButton('Damaged')
self.r3.toggled.connect(lambda: self.changeStates())
self.r4 = QRadioButton('Borrowed')
self.r4.toggled.connect(lambda: self.changeStates())
self.r5 = QRadioButton('Returned')
self.r5.toggled.connect(lambda: self.changeStates())
hboz.addWidget(self.r1)
hboz.addWidget(self.r2)
hboz.addWidget(self.r3)
hboz.addWidget(self.r4)
hboz.addWidget(self.r5)
i = 0
for a in storeGroup:
self.hold_storeGroup[i] = a['id']
tex = str(a['name']).upper()
self.storeGroupData.addItem(tex)
i += 1
i = 0
str_key = self.hold_storeGroup[self.storeGroupData.currentIndex()]
store = self.pullStore(str_key)
for a in store:
self.hold_store[i] = a['id']
tex = str(a['name']).upper()
self.storeData.addItem(tex)
i += 1
i = 0
for a in unit:
self.hold_unit[i] = a['id']
tex = str(a['name']).upper()
self.unitData.addItem(tex)
i += 1
self.reloadBorrowed()
self.FormLayout = QFormLayout()
self.FormLayout.addRow(self.storeGroupText, self.storeGroupData)
self.FormLayout.addRow(self.storeText, self.storeData)
self.FormLayout.addRow(self.tellerText, self.tellerData)
self.FormLayout.addRow(self.quantityText, self.quantityData)
self.FormLayout.addRow(self.amountText, self.amountData)
self.FormLayout.addRow(self.dateText, self.dateData)
self.FormLayout.addRow(self.periodText, self.periodData)
self.FormLayout.addRow(self.borrowedText, self.borrowedData)
self.FormLayout.addRow(self.personText, self.personData)
self.FormLayout.addRow(self.descriptionText, self.descriptionData)
self.periodText.hide()
self.periodData.hide()
mboz.addLayout(hboz)
mboz.addLayout(self.FormLayout)
mboz.addWidget(self.state)
groupBox1 = QGroupBox('Add Store Item')
groupBox1.setLayout(mboz)
self.pb = QPushButton()
self.pb.setObjectName("Add")
self.pb.setText("Add Store Item")
self.pb1 = QPushButton()
self.pb1.setObjectName("Edit")
self.pb1.setText("Edit Row")
self.pb1.setEnabled(False)
self.pb2 = QPushButton()
self.pb2.setObjectName("Close")
self.pb2.setText("Close")
self.pb3 = QPushButton()
self.pb3.setObjectName("Delete")
self.pb3.setText("Delete Row")
self.pb3.setEnabled(False)
self.pb4 = QPushButton()
self.pb4.setObjectName("Reset")
self.pb4.setText("Reset")
self.pb4.hide()
self.pb5 = QPushButton()
self.pb5.setObjectName("Change")
self.pb5.setText("Change Store")
self.pb5.hide()
self.pb6 = QPushButton()
self.pb6.setObjectName("Clear")
self.pb6.setText("Clear Selection")
self.pb6.setEnabled(False)
hbo = QHBoxLayout()
hbo.addWidget(self.pb)
hbo.addWidget(self.pb5)
hbo.addWidget(self.pb4)
hbo.addWidget(self.pb2)
groupBox2 = QGroupBox('Store Data')
groupBox2.setLayout(hbo)
al = self.pullStoreData(0)
if al and len(al) > 0:
al = al
else:
al = {}
self.storeData.currentIndexChanged.connect(
lambda: self.reloadBorrowed())
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Store")
self.table.setStyleSheet("color:white")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
#self.table.resizeColumnsToContents()
self.table.setRowCount(len(al))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in al:
#row id
if q['state'] == 1:
color = QColor(100, 0, 0)
elif q['state'] == 2:
color = QColor(100, 100, 0)
elif q['state'] == 3:
color = QColor(100, 0, 100)
elif q['state'] == 4:
color = QColor(0, 100, 100)
else:
color = QColor(0, 50, 150)
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.item(i, 0).setBackground(color)
self.table.setItem(i, 1,
QTableWidgetItem(str(q['itemname']).upper()))
self.table.item(i, 1).setBackground(color)
self.table.setItem(i, 2,
QTableWidgetItem(str(q['quantity']).upper()))
self.table.item(i, 2).setBackground(color)
try:
zamt = str("{:,}".format(float(q['amount'])))
except:
zamt = ''
self.table.setItem(i, 3, QTableWidgetItem(zamt))
self.table.item(i, 3).setBackground(color)
try:
if len(q['amount']) > 0 and float(q['amount']) > 0:
tot = float(q['amount']) * float(q['quantity'])
else:
tot = 0
except:
tot = 0
self.table.setItem(i, 4, QTableWidgetItem(str(tot).upper()))
self.table.item(i, 4).setBackground(color)
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 5, QTableWidgetItem(str(damt)))
self.table.item(i, 5).setBackground(color)
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
v_pull_box = QVBoxLayout()
self.h1_pull_box.addWidget(self.table)
v_pull_box.addLayout(h_pull_box)
v_pull_box.addLayout(self.h1_pull_box)
h2_pull_box = QHBoxLayout()
h2_pull_box.addWidget(self.pb1)
h2_pull_box.addWidget(self.pb3)
h2_pull_box.addWidget(self.pb6)
v_pull_box.addLayout(h2_pull_box)
groupBox3 = QGroupBox()
groupBox3.setLayout(hbo)
groupBox2.setLayout(v_pull_box)
grid = QGridLayout()
grid.addWidget(groupBox1, 0, 0)
grid.addWidget(groupBox2, 0, 1, 2, 1)
grid.addWidget(groupBox3, 1, 0)
self.setLayout(grid)
self.connect(self.pb, SIGNAL("clicked()"), lambda: self.button_click())
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_editshow())
self.connect(self.pb2, SIGNAL("clicked()"),
lambda: self.button_close(self))
self.connect(self.pb3, SIGNAL("clicked()"),
lambda: self.button_delete())
self.connect(self.pb4, SIGNAL("clicked()"),
lambda: self.button_reset())
self.connect(self.pb5, SIGNAL("clicked()"), lambda: self.button_edit())
self.connect(self.pb6, SIGNAL("clicked()"),
lambda: self.button_clear())
#self.connect(self.pull_btn, SIGNAL("clicked()"), lambda x =1: self.reloadTable(x))
self.setWindowTitle(self.pagetitle)
def stateReciept(self):
self.amountText.show()
self.amountData.show()
self.tellerText.show()
self.tellerData.show()
self.tellerText.setText('Reciept No.')
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Recieved By:')
self.personData.setPlaceholderText('Fullname or department')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(1)
def stateIssue(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.show()
self.tellerData.show()
self.tellerText.setText('Issue No.')
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Issued to:')
self.personData.setPlaceholderText('Fullname or department issued to')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(2)
def stateDamage(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.hide()
self.tellerData.hide()
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Reported By:')
self.personData.setPlaceholderText('Fullname or department')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(3)
def stateBorrowed(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.hide()
self.tellerData.hide()
self.periodText.show()
self.periodData.show()
self.personText.setText('Given to:')
self.personData.setPlaceholderText(
'Fullname or department borrowed to')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(4)
def stateReturned(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.hide()
self.tellerData.hide()
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Returned By:')
self.personData.setPlaceholderText(
'Fullname or department borrowed to')
self.borrowedText.show()
self.borrowedData.show()
self.reloadBorrowed()
self.reloadTable(5)
def changeStates(self):
self.getQuantity()
if self.r1.isChecked():
self.stateReciept()
elif self.r2.isChecked():
self.stateIssue()
elif self.r3.isChecked():
self.stateDamage()
elif self.r4.isChecked():
self.stateBorrowed()
elif self.r5.isChecked():
self.stateReturned()
def handleHeaderMenu(self, pos):
print('column(%d)' % self.table.horizontalHeader().logicalIndexAt(pos))
menu = QMenu()
menu.addAction('Add')
menu.addAction('Delete')
menu.exec_(QCursor.pos())
def pullGroupStore(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 23, "active": 0})
return arr
def pullStore(self, a):
cn = Db()
arr = cn.selectn('datas', '', '', {"subID": a})
return arr
def pullUnit(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 20, "active": 0})
return arr
def pullStoreData(self, a=None):
st_date = self.fromData.date().toPyDate()
en_date = self.toData.date().toPyDate()
st_date = time.mktime(st_date.timetuple())
en_date = time.mktime(en_date.timetuple())
db = 'school_stores' + str(self.session)
cn = Db()
arr = cn.selectStoreDate(db, st_date, en_date, a)
return arr
def mySelectTable(self):
'''
get the selected rpws in a table
returns list or row ids
'''
sels = self.table.selectedIndexes()
sels = self.table.selectionModel().selectedRows()
park = []
park1 = []
for j in sels:
park.append(j.row())
for i in set(park):
selected = self.table.item(i, 0).text()
park1.append(selected)
return park1
def editRow(self, a):
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
data = g.selectn(db, '', 1, {'id': a})
if len(data) > 0:
try:
amt = float(data['amount'])
qty = float(data['quantity'])
if amt > 0 and qty > 0:
cost = amt * qty
else:
cost = 0
except:
cost = 0
amt = 0
qty = 0
if data['state'] == 1:
self.r1.setChecked(True)
elif data['state'] == 2:
self.r2.setChecked(True)
elif data['state'] == 3:
self.r3.setChecked(True)
elif data['state'] == 4:
self.r4.setChecked(True)
elif data['state'] == 5:
self.r5.setChecked(True)
self.amountData.setText(str(cost))
self.descriptionData.clear()
self.descriptionData.insertPlainText(str(data['description']))
self.tellerData.setText(str(data['teller']))
self.periodData.setText(str(data['period']))
self.personData.setText(str(data['person']))
self.quantityData.setText(str(qty))
stID = self.hold_store.keys()[self.hold_store.values().index(
data['itemID'])]
self.storeData.setCurrentIndex(stID)
def reloadBorrowed(self):
self.getQuantity()
_store = self.hold_store[self.storeData.currentIndex()]
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
data = g.selectn(db, '', '', {'itemID': _store, 'state': 4})
fig = 0
self.borrowedData.clear()
self.hold_borrowed = {}
i = 0
for a in data:
ret = g.selectStoreReturned(db, a['id'])
if ret:
retu = ret['qty']
else:
retu = 0
fig = float(a['quantity']) - float(retu)
damz = float(a['datepaid'])
if float(fig) > 0:
self.hold_borrowed[i] = a['id']
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
tex = str(damt) + " " + str(
a['person']).upper() + " (" + str(fig).upper() + ")"
self.borrowedData.addItem(tex)
i += 1
def reloadStore(self):
self.getQuantity()
cat = self.hold_storeGroup[self.storeGroupData.currentIndex()]
store = self.pullStore(cat)
self.storeData.clear()
self.hold_store = {}
i = 0
for a in store:
self.hold_store[i] = a['id']
tex = str(a['name']).upper()
self.storeData.addItem(tex)
i += 1
def getQuantity(self):
if self.storeData.currentIndex() > -1:
s = self.hold_store[self.storeData.currentIndex()]
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
fi = g.selectStoreQuantity(db, s)
remain = 0
arr = {}
for a in fi:
arr[a['state']] = a['qty']
if 1 in arr:
re = arr[1]
else:
re = 0
if 2 in arr:
isu = arr[2]
else:
isu = 0
if 3 in arr:
dam = arr[3]
else:
dam = 0
if 4 in arr:
bor = arr[4]
else:
bor = 0
if 5 in arr:
ret = arr[5]
else:
ret = 0
borrowed = float(bor) - float(ret)
issued = float(isu) + float(borrowed) + float(dam)
remain = float(re) - float(issued)
self.quantityText.setText('QTY: ' + str(remain))
if remain == 0 and (self.r2.isChecked() or self.r3.isChecked()
or self.r4.isChecked()):
self.quantityData.setEnabled(False)
else:
self.quantityData.setEnabled(True)
return remain
def reloadTable(self, a):
self.getQuantity()
if not a == 0:
data = self.pullStoreData(a)
else:
data = self.pullStoreData()
self.table.close()
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Stores")
self.table.setStyleSheet("color:white")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
self.table.resizeColumnsToContents()
self.table.setRowCount(len(data))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in data:
#row id
if q['state'] == 1:
color = QColor(100, 0, 0)
elif q['state'] == 2:
color = QColor(100, 100, 0)
elif q['state'] == 3:
color = QColor(100, 0, 100)
elif q['state'] == 4:
color = QColor(0, 100, 100)
else:
color = QColor(0, 50, 150)
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.item(i, 0).setBackground(color)
self.table.setItem(i, 1,
QTableWidgetItem(str(q['itemname']).upper()))
self.table.item(i, 1).setBackground(color)
self.table.setItem(i, 2,
QTableWidgetItem(str(q['quantity']).upper()))
self.table.item(i, 2).setBackground(color)
try:
zamt = str("{:,}".format(float(q['amount'])))
except:
zamt = ''
self.table.setItem(i, 3, QTableWidgetItem(zamt))
self.table.item(i, 3).setBackground(color)
try:
if len(q['amount']) > 0 and float(q['amount']) > 0:
tot = float(q['amount']) * float(q['quantity'])
else:
tot = 0
except:
tot = 0
self.table.setItem(i, 4, QTableWidgetItem(str(tot).upper()))
self.table.item(i, 4).setBackground(color)
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 5, QTableWidgetItem(str(damt)))
self.table.item(i, 5).setBackground(color)
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
self.h1_pull_box.addWidget(self.table)
self.table.show()
def pullOnes(self, a, b):
cn = Db()
arr = cn.selectn(a, '', 1, {'id': b})
return arr
def confirmSelection(self):
item = self.mySelectTable()
if len(item) == 1:
self.pb1.setEnabled(True)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
elif len(item) > 1:
self.pb1.setEnabled(False)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
else:
self.pb1.setEnabled(False)
self.pb3.setEnabled(False)
self.pb6.setEnabled(False)
def button_close(self, b):
b.close()
def button_editshow(self):
item = self.mySelectTable()
self.editRow(item[0])
self.pb.hide()
self.pb4.show()
self.pb5.show()
def button_delete(self):
item = self.mySelectTable()
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
for j in item:
g.delete(db, {'id': j})
self.reloadTable(1)
def button_edit(self):
_session = self.session
_amounts = self.amountData.text()
_teller = self.tellerData.text()
_quantity = self.quantityData.text()
_person = self.personData.text()
_period = self.periodData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_store = self.hold_store[self.storeData.currentIndex()]
_borrowed = self.hold_borrowed[self.borrowedData.currentIndex()]
arr = {}
#recieved
if self.r1.isChecked() and _amounts and not (
_amounts == 0) and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 1
#issued
elif self.r2.isChecked() and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 2
#damaged
elif self.r3.isChecked() and int(_store) > 0 and int(_quantity) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 3
elif self.r4.isChecked() and int(_store) > 0 and int(_quantity) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['state'] = 4
elif self.r5.isChecked() and int(_store) > 0 and int(_quantity) > 0:
_borrowed = self.hold_borrowed[self.borrowedData.currentIndex()]
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['active'] = _borrowed
arr['state'] = 5
ups = {}
ups['id'] = self.editID
if int(self.editID) > 0 and len(arr) > 0:
db = 'school_stores' + str(_session)
g = Db()
g.update(db, arr, ups)
if int(self.editID) > 0:
self.button_reset()
def button_reset(self):
self.getQuantity()
self.reloadTable(1)
self.amountData.setText('')
self.descriptionData.clear()
self.tellerData.setText('')
self.personData.setText('')
self.periodData.setText('')
self.quantityData.setText('')
self.pb4.hide()
self.pb5.hide()
self.pb.show()
self.editID = 0
self.button_clear()
self.confirmSelection()
self.reloadBorrowed()
def button_clear(self):
self.table.selectionModel().clearSelection()
def button_click(self):
_session = self.session
_amounts = self.amountData.text()
_teller = self.tellerData.text()
_quantity = self.quantityData.text()
_person = self.personData.text()
_period = self.periodData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_store = self.hold_store[self.storeData.currentIndex()]
arr = {}
#recieved
if self.r1.isChecked() and _amounts and not (
_amounts == 0) and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 1
#issued
elif self.r2.isChecked() and _amounts and not (
_amounts == 0) and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 2
#damaged
elif self.r3.isChecked() and int(_store) > 0 and int(
float(_quantity)) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 3
elif self.r4.isChecked() and int(_store) > 0 and int(
float(_quantity)) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['state'] = 4
elif self.r5.isChecked() and int(_store) > 0 and int(
float(_quantity)) > 0 and self.borrowedData.currentIndex() > 0:
_borrowed = self.hold_borrowed[self.borrowedData.currentIndex()]
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['active'] = _borrowed
arr['state'] = 5
if len(arr) > 0:
db = 'school_stores' + str(_session)
g = Db()
ins = g.insert(db, arr)
if int(ins) > 0:
self.button_reset()
class wavListDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().parent().prm
self.audioManager = audioManager(self)
self.currLocale = self.parent().parent().prm['currentLocale']
self.currLocale.setNumberOptions(
self.currLocale.OmitGroupSeparator
| self.currLocale.RejectGroupSeparator)
self.isPlaying = False
self.sizer = QGridLayout()
self.v1Sizer = QVBoxLayout()
self.wavsTableWidget = QTableWidget()
self.wavsTableWidget.setColumnCount(4)
self.wavsTableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
self.wavsTableWidget.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.wavsTableWidget.setHorizontalHeaderLabels(
[self.tr("File"),
self.tr('Use'),
self.tr("RMS Level"), 'id'])
self.quidColumn = 3
self.wavsTableWidget.hideColumn(self.quidColumn)
self.wavsTableWidget.cellDoubleClicked[int, int].connect(
self.onCellDoubleClicked)
#ADD wav BUTTON
self.addWavButton = QPushButton(self.tr("Add Wav"), self)
self.addWavButton.clicked.connect(self.onClickAddWavButton)
#REMOVE wav BUTTON
self.removeWavButton = QPushButton(self.tr("Remove Wav"), self)
self.removeWavButton.clicked.connect(self.onClickRemoveWavButton)
#PLAY wav BUTTON
self.playWavButton = QPushButton(self.tr("Play Wav"), self)
self.playWavButton.clicked.connect(self.onClickPlayWavButton)
#STOP wav BUTTON
self.stopWavButton = QPushButton(self.tr("Stop Playing"), self)
self.stopWavButton.clicked.connect(self.onClickStopWavButton)
self.v1Sizer.addWidget(self.addWavButton)
self.v1Sizer.addWidget(self.removeWavButton)
self.v1Sizer.addWidget(self.playWavButton)
self.v1Sizer.addWidget(self.stopWavButton)
self.v1Sizer.addStretch()
self.wavsList = {}
for i in range(len(self.parent().wavsPref['endMessageFiles'])):
currCount = i + 1
thisID = self.parent().wavsPref['endMessageFilesID'][i]
self.wavsList[thisID] = {}
self.wavsList[thisID]['file'] = self.parent(
).wavsPref['endMessageFiles'][i]
self.wavsList[thisID]['use'] = self.parent(
).wavsPref['endMessageFilesUse'][i]
self.wavsList[thisID]['level'] = self.parent(
).wavsPref['endMessageLevels'][i]
self.wavsTableWidget.setRowCount(currCount)
n = 0
newItem = QTableWidgetItem(self.wavsList[thisID]['file'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount - 1, n, newItem)
n = n + 1
newItem = QTableWidgetItem(self.wavsList[thisID]['use'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount - 1, n, newItem)
n = n + 1
newItem = QTableWidgetItem(
self.currLocale.toString(self.wavsList[thisID]['level']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount - 1, n, newItem)
n = n + 1
self.wavsList[thisID]['qid'] = QTableWidgetItem(thisID)
self.wavsTableWidget.setItem(currCount - 1, n,
self.wavsList[thisID]['qid'])
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply
| QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
self.sizer.addLayout(self.v1Sizer, 0, 0)
self.sizer.addWidget(self.wavsTableWidget, 0, 1)
self.sizer.addWidget(buttonBox, 1, 1)
self.setLayout(self.sizer)
self.setWindowTitle(self.tr("Edit Wavs"))
self.show()
def onCellDoubleClicked(self, row, col):
if col == 0:
pass
elif col == 1:
self.onEditUse()
elif col == 2:
self.onEditLevel()
def onEditLevel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('RMS Level:')
text, ok = QInputDialog.getDouble(
self, self.tr('Input Dialog'), msg,
self.wavsList[selectedSound]['level'])
if ok:
self.wavsTableWidget.item(
self.wavsList[selectedSound]['qid'].row(),
2).setText(self.currLocale.toString(text))
self.wavsList[selectedSound]['level'] = text
def onEditUse(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
if self.wavsTableWidget.item(
self.wavsList[selectedSound]['qid'].row(),
1).text() == "\u2012":
self.wavsTableWidget.item(
self.wavsList[selectedSound]['qid'].row(),
1).setText("\u2713")
self.wavsList[selectedSound]['use'] = "\u2713"
else:
self.wavsTableWidget.item(
self.wavsList[selectedSound]['qid'].row(),
1).setText("\u2012")
self.wavsList[selectedSound]['use'] = "\u2012"
def findSelectedItemIds(self):
selItems = self.wavsTableWidget.selectedItems()
selItemsRows = []
for i in range(len(selItems)):
selItemsRows.append(selItems[i].row())
selItemsRows = unique(selItemsRows)
selItemsIds = []
for i in range(len(selItemsRows)):
selItemsIds.append(
str(
self.wavsTableWidget.item(selItemsRows[i],
self.quidColumn).text()))
return selItemsIds
def permanentApply(self):
self.wavListToPass = {}
self.wavListToPass['endMessageFiles'] = []
self.wavListToPass['endMessageFilesUse'] = []
self.wavListToPass['endMessageFilesID'] = []
self.wavListToPass['endMessageLevels'] = []
keys = sorted(self.wavsList.keys())
for key in keys:
self.wavListToPass['endMessageFiles'].append(
str(self.wavsList[key]['file']))
self.wavListToPass['endMessageFilesUse'].append(
self.wavsList[key]['use'])
self.wavListToPass['endMessageLevels'].append(
self.wavsList[key]['level'])
self.wavListToPass['endMessageFilesID'].append(key)
def onClickAddWavButton(self):
fName = QFileDialog.getOpenFileName(
self, self.tr("Choose wav file to load"), '',
self.tr("wav files (*.wav);;All Files (*)"))[0]
if len(fName) > 0: #if the user didn't press cancel
if len(self.wavsList.keys()) > 0:
keys = sorted(self.wavsList.keys())
thisID = str(int(keys[-1]) + 1)
else:
thisID = "1"
currCount = self.wavsTableWidget.rowCount() + 1
self.wavsList[thisID] = {}
self.wavsList[thisID]['file'] = fName
self.wavsList[thisID]['use'] = "\u2713"
self.wavsList[thisID]['level'] = 60
self.wavsTableWidget.setRowCount(currCount)
n = 0
newItem = QTableWidgetItem(self.wavsList[thisID]['file'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount - 1, n, newItem)
n = n + 1
newItem = QTableWidgetItem(self.wavsList[thisID]['use'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount - 1, n, newItem)
n = n + 1
newItem = QTableWidgetItem(
self.currLocale.toString(self.wavsList[thisID]['level']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.wavsTableWidget.setItem(currCount - 1, n, newItem)
n = n + 1
self.wavsList[thisID]['qid'] = QTableWidgetItem(thisID)
self.wavsTableWidget.setItem(currCount - 1, n,
self.wavsList[thisID]['qid'])
def onClickRemoveWavButton(self):
ids = self.findSelectedItemIds()
for i in range(len(ids)):
selectedWavs = ids[i]
self.wavsTableWidget.removeRow(
self.wavsList[selectedWavs]['qid'].row())
del self.wavsList[selectedWavs]
def onClickPlayWavButton(self):
ids = self.findSelectedItemIds()
if len(ids) < 1:
QMessageBox.warning(self, self.tr('Warning'),
self.tr('No files selected for playing'))
else:
if len(ids) > 1:
pass #maybe say on the status bar that only the first one will be played
selectedWav = ids[0]
fName = self.wavsList[selectedWav]['file']
level = self.wavsList[selectedWav]['level']
nBits = self.currLocale.toInt(
self.parent().parent().nBitsChooser.currentText())[0]
maxLevel = float(self.prm['phones']['phonesMaxLevel'][
self.parent().parent().phonesChooser.currentIndex()])
msgSnd, fs = self.audioManager.loadWavFile(fName, level, maxLevel,
'Both')
self.isPlaying = True
if self.prm['pref']['sound']['playCommand'] in [
"alsaaudio", "pyaudio"
]:
self.playThread = threadedAudioPlayer(self.parent().parent())
else:
self.playThread = threadedExternalAudioPlayer(
self.parent().parent())
self.playThread.playThreadedSound(
msgSnd, fs, nBits, self.prm['pref']['sound']['playCommand'],
False, 'tmp.wav')
if self.playThread.isFinished == True:
self.isPlaying = False
def onClickStopWavButton(self):
if self.isPlaying == True:
self.playThread.terminate()
def closeEvent(self, event):
if self.isPlaying == True:
self.playThread.terminate()
event.accept()
def accept(self): #reimplement accept (i.e. ok button)
if self.isPlaying == True:
self.playThread.terminate()
QDialog.accept(self)
def reject(self): #reimplement reject
if self.isPlaying == True:
self.playThread.terminate()
QDialog.reject(self)
class CorrectorViewer(QtGui.QWidget):
"""
List all corrector and select part to lower table
"""
def __init__(self, cors, field, parent=None, nmax=4):
super(CorrectorViewer, self).__init__(parent)
self._nmax = nmax
self._field = field
self._cors = cors
self._corlst1 = QtGui.QTreeWidget()
self._header = dict([("Element", 0), ("Family", 1), ("s [m]", 2),
("Alpha X", 3), ("Alpha Y", 4), ("Beta X", 5),
("Beta Y", 6), ("Phi X", 7), ("Phi Y", 8),
("Eta X", 9)])
self._twiss = np.zeros((len(self._cors), 8), 'd')
self._tunes = getTunes(source="database")
self._corlst1.setColumnCount(len(self._header))
self._corlst1.setHeaderLabels(
sorted(self._header, key=self._header.get))
self._corlst1.header().setStretchLastSection(False)
prevcell = None
for i,c in enumerate(self._cors):
if c.cell and (prevcell is None or c.cell != prevcell.text(0)):
# a new parent
prevcell = QtGui.QTreeWidgetItem()
prevcell.setText(0, c.cell)
self._corlst1.addTopLevelItem(prevcell)
it = QtGui.QTreeWidgetItem()
it.setData(0, Qt.UserRole, i)
it.setText(self._header["Element"], c.name)
it.setText(self._header["Family"], c.family)
it.setText(self._header["s [m]"], "%.3f" % c.sb)
try:
tw = getTwiss(c.name,
["s", "alphax", "alphay", "betax", "betay",
"phix", "phiy", "etax"])
self._twiss[i,:] = tw[0,:]
it.setText(self._header["Alpha X"], "%.4f" % self._twiss[i,1])
it.setText(self._header["Alpha Y"], "%.4f" % self._twiss[i,2])
it.setText(self._header["Beta X"], "%.4f" % self._twiss[i,3])
it.setText(self._header["Beta Y"], "%.4f" % self._twiss[i,4])
it.setText(self._header["Phi X"], "%.4f" % self._twiss[i,5])
it.setText(self._header["Phi Y"], "%.4f" % self._twiss[i,6])
it.setText(self._header["Eta X"], "%.4f" % self._twiss[i,7])
except:
it.setDisabled(True)
pass
if c.cell:
prevcell.addChild(it)
else:
self._corlst1.addTopLevelItem(it)
prevcell = it
for j in range(2, len(self._header)):
it.setTextAlignment(j, Qt.AlignRight)
self._corlst1.expandAll()
for i in range(len(self._header)):
self._corlst1.resizeColumnToContents(i)
#self._corlst1.setColumnWidth(0, 150)
#self.elemlst.setSelectionMode(QAbstractItemView.MultiSelection)
columns = ['Corrector', 's', 'Alpha', 'Beta',
'Phi', "dPhi", "Initial Bump", "Cur. Sp", "dBump",
"Final Rb"]
self.table4 = QTableWidget(0, len(columns))
#self.table4.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
hdview = QHeaderView(Qt.Horizontal)
self.table4.setHorizontalHeaderLabels(columns)
#for i in range(4):
# for j in range(len(columns)):
# it = QTableWidgetItem()
# if j > 0: it.setTextAlignment(
# Qt.AlignRight | Qt.AlignVCenter)
# if columns[j] != "dKick":
# it.setFlags(it.flags() & (~Qt.ItemIsEditable))
# self.table4.setItem(i, j, it)
#self.table4.resizeColumnsToContents()
#self.table4.horizontalHeader().setStretchLastSection(True)
#hrow = self.table4.rowHeight(0)
#htbl = (hrow * 4) + self.table4.horizontalHeader().height() +\
# 2*self.table4.frameWidth()
#self.table4.setMinimumHeight(htbl + 10)
#self.table4.setMaximumHeight(htbl + 15)
#self.table4.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#print "Size:", htbl + 10
self.table4.resize(self.table4.width(), 150)
splitter = QtGui.QSplitter(Qt.Vertical)
splitter.addWidget(self._corlst1)
splitter.addWidget(self.table4)
vbox1 = QtGui.QVBoxLayout()
vbox1.addWidget(splitter)
self.setLayout(vbox1)
self.connect(self._corlst1, SIGNAL("doubleClicked(QModelIndex)"),
self.addCorrector)
#self.connect(self.src, SIGNAL("returnPressed()"),
# self._calc_source)
#self.connect(self.table4, SIGNAL("cellChanged(int, int)"),
# self.updateTable)
#self.connect(self.table4, SIGNAL("doubleClicked(QModelIndex)"),
# self.delCorrector)
self._x0 = fget(self._cors, "x", handle="setpoint", unitsys=None)
self._y0 = fget(self._cors, "y", handle="setpoint", unitsys=None)
def addCorrector(self, idx):
if not self._corlst1.selectedItems(): return
#print self._corlst1.itemFromIndex(idx).text(0)
nrow = self.table4.rowCount()
if nrow >= self._nmax:
QtGui.QMessageBox.critical(
self, "Local Orbit Bump",
"ERROR: We need only {0} correctors.".format(self._nmax),
QtGui.QMessageBox.Ok)
#self.progress.setValue(0)
return
self.table4.setRowCount(nrow+1)
it0 = self._corlst1.selectedItems()[-1]
icor, ok = it0.data(0, Qt.UserRole).toInt()
if icor < 0: return
newc = self._cors[icor]
for j in range(self.table4.columnCount()):
it = QTableWidgetItem()
if j > 0: it.setTextAlignment(
Qt.AlignRight | Qt.AlignVCenter)
header = self.table4.horizontalHeaderItem(j)
if header.text() != "dBump":
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
else:
it.setData(Qt.DisplayRole, "0")
it.setData(Qt.UserRole, 0.0)
self.table4.setItem(nrow, j, it)
self.table4.item(nrow,0).setData(Qt.UserRole, icor)
for j,h in [(0, "Element"), (1, "s [m]")]:
self.table4.item(nrow,j).setData(Qt.DisplayRole,
it0.text(self._header[h]))
for j in range(self._corlst1.columnCount()):
it0.setForeground(j, Qt.red)
it0.setDisabled(True)
self.emit(SIGNAL("correctorAdded(PyQt_PyObject)"), newc)
# use initial values
self.updateTwiss()
self.updateCorReadings()
self.table4.resizeColumnsToContents()
if self.table4.rowCount() == self._nmax:
#print "All correctors are ready"
self.emit(SIGNAL("correctorsComplete()"))
def updateTwiss(self):
if self._field == "x":
jl = [self._header[h] for h in ["Alpha X", "Beta X", "Phi X"]]
nu = self._tunes[0]
elif self._field == "y":
jl = [self._header[h] for h in ["Alpha Y", "Beta Y", "Phi Y"]]
nu = self._tunes[1]
else:
raise RuntimeError("unknown cor field {0}".format(self._field))
#print "index:", jl
# if rows provided use it, otherwise use all
for i in range(self.table4.rowCount()):
elemname = self.table4.item(i,0).data(Qt.DisplayRole).toString()
it0 = self._corlst1.findItems(
elemname, Qt.MatchExactly | Qt.MatchRecursive)[0]
self.table4.item(i,2).setText(it0.text(jl[0]))
self.table4.item(i,3).setText(it0.text(jl[1]))
self.table4.item(i,4).setText(it0.text(jl[2]))
self.table4.item(i,4).setData(Qt.UserRole, float(it0.text(jl[2])))
if i == 0:
self.table4.item(i,5).setText("0.0")
self.table4.item(i,5).setData(Qt.UserRole, 0.0)
else:
dph, ok = self.table4.item(i-1,5).data(Qt.UserRole).toFloat()
ph0, ok = self.table4.item(i-1,4).data(Qt.UserRole).toFloat()
ph1, ok = self.table4.item(i,4).data(Qt.UserRole).toFloat()
dph = dph + ph1 - ph0
if ph1 < ph0:
dph = dph + 2.0*np.pi*nu
#print "Updating twiss:", i, dph
self.table4.item(i,5).setData(Qt.UserRole, dph)
self.table4.item(i,5).setText("%.5g" % dph)
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
#c = self._cors[icor]
#kick = self._cors[icor].get(self._field, unitsys=None)
#self.table4.item(i,6).setData(Qt.UserRole, kick)
#self.table4.item(i,6).setText("%.5g" % kick)
#self.updateKickReadings(col=0)
def clear(self):
for i in range(self.table4.rowCount()):
elemname = self.table4.item(i,0).data(Qt.DisplayRole).toString()
it0 = self._corlst1.findItems(
elemname, Qt.MatchExactly | Qt.MatchRecursive)[0]
it0.setDisabled(False)
for j in range(self._corlst1.columnCount()):
it0.setForeground(j, Qt.black)
self.table4.setRowCount(0)
def updateCorReadings(self):
for i in range(self.table4.rowCount()):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
cor = self._cors[icor]
if self._field == "x":
self.table4.item(i,6).setData(Qt.UserRole, self._x0[icor])
self.table4.item(i,6).setText("%.5g" % self._x0[icor])
elif self._field == "y":
self.table4.item(i,6).setData(Qt.UserRole, self._y0[icor])
self.table4.item(i,6).setText("%.5g" % self._y0[icor])
kicksp = cor.get(self._field, handle="setpoint", unitsys=None)
self.table4.item(i,7).setData(Qt.UserRole, float(kicksp))
self.table4.item(i,7).setText("%.5g" % kicksp)
kickrb = cor.get(self._field, handle="readback", unitsys=None)
self.table4.item(i,9).setData(Qt.UserRole, float(kickrb))
self.table4.item(i,9).setText("%.5g" % kickrb)
def updateDbump(self, dkick):
nrow = min(self.table4.rowCount(), len(dkick))
for i in range(nrow):
# dbump column is 8
it = self.table4.item(i, 8)
if dkick[i] is None:
it.setData(Qt.DisplayRole, "")
it.setData(Qt.UserRole, 0.0)
else:
it.setData(Qt.UserRole, float(dkick[i]))
it.setData(Qt.DisplayRole, "{0}".format(dkick[i]))
self.updateCorReadings()
self.table4.resizeColumnsToContents()
#print "(0,7)", self.table4.item(0, 7).data(Qt.UserRole).toFloat()
#print "(0,7)", self.table4.item(0, 7).data(Qt.DisplayRole).toFloat()
def applyKick(self):
nrow = self.table4.rowCount()
for i in range(nrow):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
cor = self._cors[icor]
# Current SP: 7, dBump 8
k0, ok = self.table4.item(i, 7).data(Qt.UserRole).toFloat()
dk, ok = self.table4.item(i, 8).data(Qt.UserRole).toFloat()
#print "Setting {0} {1}+{2} [A]".format(cor.name, k0, dk)
cor.put(self._field, k0+dk, unitsys=None)
# update the final readings
self.updateCorReadings()
def getTwiss(self):
tw = {"s": [], "Alpha": [], "Beta": [],
"Phi": [], "dPhi": []}
nrow = self.table4.rowCount()
for j in range(self.table4.columnCount()):
header = self.table4.horizontalHeaderItem(j)
if header.text() not in tw.keys():
continue
k = str(header.text())
for i in range(nrow):
it = self.table4.item(i, j)
v0, ok0 = it.data(Qt.UserRole).toFloat()
v1, ok1 = it.data(Qt.DisplayRole).toFloat()
if ok0:
tw[k].append(v0)
elif ok1:
tw[k].append(v1)
else:
tw[k].append(np.nan)
return tw
def selectedCorrectors(self):
ret = []
for i in range(self.table4.rowCount()):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
ret.append(self._cors[icor])
return ret
def resetCorrectors(self):
for i in range(self.table4.rowCount()):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
cor = self._cors[icor]
if self._field == "x":
kick = self._x0[icor]
elif self._field == "y":
kick = self._y0[icor]
cor.put(self._field, kick, unitsys=None)
class OrbitCorrGeneral(QtGui.QWidget):
"""
A general orbit correction or local bump panel.
"""
def __init__(self, bpms, cors, parent = None):
super(OrbitCorrGeneral, self).__init__(parent)
self.bpms, self.cors = bpms, cors
self.sb = [bpm.sb for bpm in self.bpms]
self.x0, self.y0 = None, None
self._update_current_orbit()
self.table = QTableWidget(len(self.bpms), 9)
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
hdview = QHeaderView(Qt.Horizontal)
self.table.setHorizontalHeaderLabels(
['BPM Name', 's', "Beta X", "Beta Y",
"Eta X", 'X Bump', 'Y Bump', "Target X", "Target Y"])
self._twiss = getTwiss([b.name for b in self.bpms],
["s", "betax", "betay", "etax"])
for i,bpm in enumerate(self.bpms):
it = QTableWidgetItem(bpm.name)
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
self.table.setItem(i, 0, it)
it = QTableWidgetItem(str(bpm.sb))
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
#it.setMinimumWidth(80)
self.table.setItem(i, 1, it)
self.table.setItem(i, 2,
QTableWidgetItem("%.4f" % self._twiss[i,1]))
self.table.setItem(i, 3,
QTableWidgetItem("%.4f" % self._twiss[i,2]))
self.table.setItem(i, 4,
QTableWidgetItem("%.4f" % self._twiss[i,3]))
for j in range(5, 9):
it = QTableWidgetItem(str(0.0))
it.setData(Qt.DisplayRole, str(0.0))
it.setFlags(it.flags() | Qt.ItemIsEditable)
self.table.setItem(i, j, it)
# use the current orbit
#self.table.item(i,4).setData(Qt.DisplayRole, str(self.x0[i]))
#self.table.item(i,5).setData(Qt.DisplayRole, str(self.y0[i]))
#self.connect(self.table, SIGNAL("cellClicked(int, int)"),
# self._cell_clicked)
self.table.resizeColumnsToContents()
#self.table.horizontalHeader().setStretchLastSection(True)
#for i in range(4):
# print "width", i, self.table.columnWidth(i)
#self.table.setColumnWidth(0, 300)
self.table.setColumnWidth(1, 80)
vbox1 = QtGui.QVBoxLayout()
frmbox = QFormLayout()
self.base_orbit_box = QtGui.QComboBox()
#self.base_orbit_box.addItems([
# "Current Orbit", "All Zeros"])
self.base_orbit_box.addItems(["All Zeros", "Current Orbit"])
frmbox.addRow("Orbit Base", self.base_orbit_box)
grp = QtGui.QGroupBox("Local Bump")
grp.setLayout(frmbox)
vbox1.addWidget(grp)
frmbox = QFormLayout()
hln1 = QtGui.QFrame()
hln1.setLineWidth(3)
hln1.setFrameStyle(QtGui.QFrame.Sunken)
hln1.setFrameShape(QtGui.QFrame.HLine)
frmbox.addRow(hln1)
self.repeatbox = QSpinBox()
self.repeatbox.setRange(1, 20)
self.repeatbox.setValue(3)
# or connect the returnPressed() signal
frmbox.addRow("&Repeat correction", self.repeatbox)
self.rcondbox = QLineEdit()
self.rcondbox.setValidator(QDoubleValidator(0, 1, 0, self))
self.rcondbox.setText("1e-2")
frmbox.addRow("r&cond for SVD", self.rcondbox)
self.scalebox = QDoubleSpinBox()
self.scalebox.setRange(0.01, 5.00)
self.scalebox.setSingleStep(0.01)
self.scalebox.setValue(0.68)
frmbox.addRow("&Scale correctors", self.scalebox)
#hln2 = QtGui.QFrame()
#hln2.setLineWidth(3)
#hln2.setFrameStyle(QtGui.QFrame.Sunken)
#hln2.setFrameShape(QtGui.QFrame.HLine)
#frmbox.addRow(hln2)
self.progress = QProgressBar()
self.progress.setMaximum(self.repeatbox.value())
self.progress.setMaximumHeight(15)
frmbox.addRow("Progress", self.progress)
grp = QtGui.QGroupBox("Correction")
grp.setLayout(frmbox)
vbox1.addWidget(grp)
#vbox.addStretch(1.0)
#self.qdb = QDialogButtonBox(self)
#self.qdb.addButton("APP", QDialogButtonBox.ApplyRole)
#self.qdb.addButton("R", QDialogButtonBox.ResetRole)
#btn.setDefault(True)
#self.qdb.addButton(QDialogButtonBox.Cancel)
#self.qdb.addButton(QDialogButtonBox.Help)
gbox = QtGui.QGridLayout()
btn = QPushButton("Clear")
self.connect(btn, SIGNAL("clicked()"), self.resetBumps)
gbox.addWidget(btn, 0, 1)
self.correctOrbitBtn = QPushButton("Apply")
#self.correctOrbitBtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.correctOrbitBtn.setStyleSheet("QPushButton:disabled { color: gray }");
self.connect(self.correctOrbitBtn, SIGNAL("clicked()"), self.call_apply)
self.correctOrbitBtn.setDefault(True)
gbox.addWidget(self.correctOrbitBtn, 1, 1)
gbox.setColumnStretch(0, 1)
vbox1.addStretch()
vbox1.addLayout(gbox)
hbox1 = QtGui.QHBoxLayout()
hbox1.addWidget(self.table, 2)
hbox1.addLayout(vbox1, 0)
self.setLayout(hbox1)
self.connect(self.base_orbit_box,
SIGNAL("currentIndexChanged(QString)"),
self.updateTargetOrbit)
self.connect(self.repeatbox, SIGNAL("valueChanged(int)"),
self.progress.setMaximum)
self.connect(self.table, SIGNAL("cellChanged (int, int)"),
self.updateBump)
#self.updateTargetOrbit(self.base_orbit_box.currentText())
def _update_current_orbit(self):
pvx = [bpm.pv(field="x", handle="readback")[0] for bpm in self.bpms]
pvy = [bpm.pv(field="y", handle="readback")[0] for bpm in self.bpms]
self.x0 = [float(v) if v.ok else np.nan for v in catools.caget(pvx)]
self.y0 = [float(v) if v.ok else np.nan for v in catools.caget(pvy)]
def resetBumps(self):
jx0, jy0 = 5, 6
for i in range(self.table.rowCount()):
self.table.item(i, jx0).setData(Qt.DisplayRole, str(0.0))
self.table.item(i, jy0).setData(Qt.DisplayRole, str(0.0))
#self.updateTargetOrbit(self.base_orbit_box.currentText())
def call_apply(self):
#print "apply the orbit"
obt = []
jx, jy = 7, 8
for i in range(self.table.rowCount()):
x1,err = self.table.item(i, jx).data(Qt.DisplayRole).toFloat()
y1,err = self.table.item(i, jy).data(Qt.DisplayRole).toFloat()
obt.append([x1, y1])
self.correctOrbitBtn.setEnabled(False)
nrepeat = self.repeatbox.value()
kw = { "scale": float(self.scalebox.text()),
"rcond": float(self.rcondbox.text()) }
self.progress.setValue(0)
QApplication.processEvents()
for i in range(nrepeat):
err, msg = setLocalBump(self.bpms, self.cors, obt, **kw)
self.progress.setValue(i+1)
QApplication.processEvents()
if err != 0:
QtGui.QMessageBox.critical(
self, "Local Orbit Bump",
"ERROR: {0}\nAbort.".format(msg),
QtGui.QMessageBox.Ok)
#self.progress.setValue(0)
break
self.correctOrbitBtn.setEnabled(True)
def getTargetOrbit(self):
x = [self.table.item(i,7).data(Qt.DisplayRole).toFloat()[0]
for i in range(self.table.rowCount())]
y = [self.table.item(i,8).data(Qt.DisplayRole).toFloat()[0]
for i in range(self.table.rowCount())]
return (self.sb, x), (self.sb, y)
def updateTargetOrbit(self, baseobt):
if baseobt == "All Zeros":
jx0, jx1 = 5, 7
jy0, jy1 = 6, 8
for i in range(self.table.rowCount()):
it0 = self.table.item(i, jx0)
it1 = self.table.item(i, jx1)
it1.setData(Qt.DisplayRole, it0.data(Qt.DisplayRole))
it0 = self.table.item(i, jy0)
it1 = self.table.item(i, jy1)
it1.setData(Qt.DisplayRole, it0.data(Qt.DisplayRole))
elif baseobt == "Current Orbit":
self._update_current_orbit()
jx0, jx1 = 5, 7
jy0, jy1 = 6, 8
for i in range(self.table.rowCount()):
dx0,err = self.table.item(i, jx0).data(Qt.DisplayRole).toFloat()
it = self.table.item(i, jx1)
it.setData(Qt.DisplayRole, self.x0[i] + dx0)
dy0,err = self.table.item(i, jy0).data(Qt.DisplayRole).toFloat()
it = self.table.item(i, jy1)
it.setData(Qt.DisplayRole, self.y0[i] + dy0)
#self._update_orbit_plot()
x, y = self.getTargetOrbit()
self.emit(SIGNAL("targetOrbitChanged(PyQt_PyObject, PyQt_PyObject)"),
x, y)
def updateBump(self, row, col):
#print "updating ", row, col
if col == 5 or col == 6:
self.updateTargetOrbit(self.base_orbit_box.currentText())
class multirun_widget(QWidget):
"""Widget for editing multirun values.
Keyword arguments:
tr -- a translate instance that contains the experimental sequence
nrows -- number of rows = number of multirun steps.
ncols -- number of columns = number of channels to change in one step.
order -- the order to produce the variables list in:
ascending - with repeats next to each other
descending - with repeats next to each other
random - completely randomise the order
coarse random - randomise order but repeats next to each other
unsorted - make an ascending list, then repeat the list
"""
multirun_vals = pyqtSignal(np.ndarray) # the array of multirun values
progress = pyqtSignal(str) # string detailing the progress of the multirun
def __init__(self, tr, nrows=1, ncols=1, order='ascending'):
super().__init__()
self.tr = tr # translator for the current sequence
self.mrtr = tr.copy() # translator for multirun sequence
self.msglist = [] # list of multirun sequences as XML string
self.ind = 0 # index for how far through the multirun we are
self.nrows = nrows
self.ncols = ncols
self.types = OrderedDict([('measure', int), ('measure_prefix', str),
('1st hist ID', int),
('Variable label', str), ('Order', str),
('Type', strlist),
('Analogue type', strlist),
('Time step name', listlist),
('Analogue channel', listlist),
('runs included', listlist),
('Last time step run', str),
('Last time step end', str),
('# omitted', int), ('# in hist', int),
('list index', strlist)])
self.ui_param = OrderedDict([
('measure', 0), ('measure_prefix', 'Measure0'),
('1st hist ID', -1), ('Variable label', ''), ('Order', order),
('Type', ['Time step length'] * ncols),
('Analogue type', ['Fast analogue'] * ncols),
('Time step name', [[]] * ncols),
('Analogue channel', [[]] * ncols),
('runs included', [[] for i in range(nrows)]),
('Last time step run',
r'C:\Users\lab\Desktop\DExTer 1.4\Last Timesteps\feb2020_940and812.evt'
),
('Last time step end',
r'C:\Users\lab\Desktop\DExTer 1.4\Last Timesteps\feb2020_940and812.evt'
), ('# omitted', 5), ('# in hist', 100),
('list index', ['0'] * ncols)
])
self.awg_args = [
'duration_[ms]', 'off_time_[us]', 'freqs_input_[MHz]',
'start_freq_[MHz]', 'end_freq_[MHz]', 'hybridicity',
'num_of_traps', 'distance_[um]', 'tot_amp_[mV]', 'dc_offset_[mV]',
'start_amp', 'end_amp', 'start_output_[Hz]', 'end_output_[Hz]',
'freq_amp', 'mod_freq_[kHz]', 'mod_depth', 'freq_phase_[deg]',
'freq_adjust', 'amp_adjust', 'freqs_output_[Hz]', 'num_of_samples',
'duration_loop_[ms]', 'number_of_cycles'
]
self.dds_args = [
'Freq', 'Phase', 'Amp', 'Start_add', 'End_add', 'Step_rate',
'Sweep_start', 'Sweep_end', 'Pos_step', 'Neg_step',
'Pos_step_rate', 'Neg_step_rate'
]
self.slm_args = [
'f', 'period', 'angle', 'radius', 'gradient', 'shift', 'radial',
'azimuthal', 'amplitude'
]
self.column_options = [
'Analogue voltage', 'AWG1 chan : seg', 'AWG2 chan : seg',
'DDS1 port : profile', 'DDS2 module : profile', 'SLM holograms'
] # these analogue types require the analogue options
self.col_range_text = [''] * ncols
self.COM = ['RB1A', 'RB2', 'RB3', 'RB4',
'RB1B'] # DDS COM port connections
self.COM2 = ['1557', '977', '1013', '420'] # DDS2 module connections
self.mr_param = copy.deepcopy(
self.ui_param) # parameters used for current multirun
self.mr_vals = [] # multirun values for the current multirun
self.mr_queue = [
] # list of parameters, sequences, and values to queue up for future multiruns
self.appending = False # whether the current multirun will be appended on to the displayed results
self.multirun = False # whether a multirun is running or not
self.QueueWindow = QMainWindow() # window for editing mr queue
self.QueueWindow.setStyleSheet("background-color: cyan;")
self.queue_ui = Ui_QueueWindow(self.mr_queue)
self.queue_ui.setupUi(self.QueueWindow)
self.init_UI() # make the widgets
self.ss = sequenceSaver(self.mrtr, self.mr_vals, self.mr_param,
'') # used to save sequences
def make_label_edit(self,
label_text,
layout,
position=[0, 0, 1, 1],
default_text='',
validator=None):
"""Make a QLabel with an accompanying QLineEdit and add them to the
given layout with an input validator. The position argument should
be [row number, column number, row width, column width]."""
label = QLabel(label_text, self)
layout.addWidget(label, *position)
line_edit = QLineEdit(self)
if np.size(position) == 4:
position[1] += 1
layout.addWidget(line_edit, *position)
line_edit.setText(default_text)
line_edit.setValidator(validator)
return label, line_edit
def init_UI(self):
"""Create all of the widget objects required"""
layout = QVBoxLayout()
self.setLayout(layout)
# place scroll bars if the contents of the window are too large
scroll = QScrollArea(self)
layout.addWidget(scroll)
scroll_content = QWidget(scroll)
scroll.setWidgetResizable(True)
scroll.setFixedHeight(800)
self.grid = QGridLayout()
scroll_content.setLayout(self.grid)
#### validators for user input ####
double_validator = QDoubleValidator() # floats
int_validator = QIntValidator(0, 10000000) # positive integers
msr_validator = QIntValidator(-1, 1000000) # integers >= -1
nat_validator = QIntValidator(1, 10000000) # natural numbers
col_validator = QIntValidator(1,
self.ncols - 1) # for number of columns
#### table dimensions and ordering ####
# choose the number of rows = number of multirun steps
labels = ['# Omit', '# in Histogram', '# Columns', '# Rows']
default = ['5', '100', str(self.ncols), str(self.nrows)]
vldtr = [int_validator, nat_validator, nat_validator, nat_validator]
self.omit_edit, self.nhist_edit, self.cols_edit, self.rows_edit = [
self.make_label_edit(labels[i], self.grid, [0, 2 * i, 1, 1],
default[i], vldtr[i])[1] for i in range(4)
]
self.cols_edit.textChanged[str].connect(self.change_array_size)
self.rows_edit.textChanged[str].connect(self.change_array_size)
self.omit_edit.editingFinished.connect(self.update_repeats)
self.nhist_edit.editingFinished.connect(self.update_repeats)
# choose the order
self.order_edit = QComboBox(self)
self.order_edit.addItems(
['ascending', 'descending', 'random', 'coarse random', 'unsorted'])
self.grid.addWidget(self.order_edit, 0, 8, 1, 1)
#### create multirun list of values ####
# metadata for the multirun list: which channels and timesteps
self.measures = OrderedDict()
labels = ['Variable label', 'measure', 'measure_prefix', '1st hist ID']
defaults = ['Variable 0', '0', 'Measure0', '0']
for i in range(len(labels)):
label = QLabel(labels[i], self)
self.grid.addWidget(label, i + 1, 0, 1, 1)
self.measures[labels[i]] = QLineEdit(defaults[i], self)
self.measures[labels[i]].textChanged.connect(self.update_all_stats)
self.grid.addWidget(self.measures[labels[i]], i + 1, 1, 1, 3)
self.measures['measure'].setValidator(int_validator)
self.measures['1st hist ID'].setValidator(msr_validator)
label.setText('1st ID (-1 to append)') # change label
self.chan_choices = OrderedDict()
labels = [
'Type', 'Time step name', 'Analogue type', 'Analogue channel'
]
sht = self.tr.get_esc()[2][2:] # 'Sequence header top'
options = [
[
'Time step length', 'Analogue voltage', 'GPIB',
'AWG1 chan : seg', 'AWG2 chan : seg', 'DDS1 port : profile',
'DDS2 module : profile', 'SLM holograms', 'Other'
],
list(
map(str.__add__, [str(i) for i in range(len(sht))],
[': ' + hc[6][1].text for hc in sht])), # time step names
['Fast analogue', 'Slow analogue'],
self.get_anlg_chans('Fast')
]
positions = [[1, 4, 3, 2], [1, 6, 6, 1], [1, 7, 3, 1], [1, 8, 6, 1]]
widgets = [QComboBox, QListWidget]
for i in range(0, len(labels)):
self.chan_choices[labels[i]] = widgets[i % 2]()
if i % 2:
self.chan_choices[labels[i]].setSelectionMode(3)
self.chan_choices[labels[i]].addItems(options[i])
self.grid.addWidget(self.chan_choices[labels[i]], *positions[i])
self.chan_choices['Type'].currentTextChanged[str].connect(
self.change_mr_type)
self.chan_choices['Analogue type'].currentTextChanged[str].connect(
self.change_mr_anlg_type)
self.chan_choices['Analogue channel'].setEnabled(False)
# enter desired time step selection via python cmd
self.index_slice = QLineEdit('range(0,1,2)', self)
self.grid.addWidget(self.index_slice, 3, 4, 3, 2)
self.apply_slice_btn = QPushButton('Apply range', self)
self.grid.addWidget(self.apply_slice_btn, 4, 4, 3, 2)
self.apply_slice_btn.clicked.connect(self.apply_slice)
# AWG takes a list for some arguments, so needs an index
label = QLabel('List index:', self)
self.grid.addWidget(label, 3, 7, 3, 1)
self.list_index = QLineEdit('0', self)
self.grid.addWidget(self.list_index, 4, 7, 3, 1)
self.list_index.setValidator(int_validator)
self.list_index.textEdited[str].connect(self.save_chan_selection)
# add a new list of multirun values to the array
self.col_index = self.make_label_edit('column index:',
self.grid,
position=[5, 0, 1, 1],
default_text='0',
validator=col_validator)[1]
self.col_range = QLineEdit('np.linspace(0,1,%s)' % (self.nrows), self)
self.grid.addWidget(self.col_range, 5, 2, 1, 2)
# show the previously selected channels for this column:
self.chan_choices['Time step name'].itemClicked.connect(
self.save_chan_selection)
self.chan_choices['Analogue channel'].itemClicked.connect(
self.save_chan_selection)
self.col_range.editingFinished.connect(self.save_chan_selection)
self.col_index.textChanged[str].connect(self.set_chan_listbox)
# add the column to the multirun values array
add_var_button = QPushButton('Add column', self)
add_var_button.clicked.connect(self.add_column_to_array)
add_var_button.resize(add_var_button.sizeHint())
self.grid.addWidget(add_var_button, 6, 0, 1, 1)
# clear the current list of user variables
clear_vars_button = QPushButton('Clear', self)
clear_vars_button.clicked.connect(self.clear_array)
clear_vars_button.resize(clear_vars_button.sizeHint())
self.grid.addWidget(clear_vars_button, 6, 1, 1, 1)
# suggest new measure when multirun started
self.suggest_button = QPushButton('Auto-increment measure',
self,
checkable=True,
checked=True)
self.suggest_button.resize(self.suggest_button.sizeHint())
self.grid.addWidget(self.suggest_button, 6, 2, 1, 2)
# choose last time step for multirun
lts_label = QLabel('Last time step: ', self)
self.grid.addWidget(lts_label, 7, 0, 1, 1)
self.last_step_run_edit = self.make_label_edit('Running: ',
self.grid,
position=[7, 1, 1,
3])[1]
self.last_step_run_edit.setText(self.ui_param['Last time step run'])
self.last_step_run_edit.textChanged[str].connect(self.update_last_step)
self.last_step_end_edit = self.make_label_edit('End: ',
self.grid,
position=[7, 5, 1,
3])[1]
self.last_step_end_edit.setText(self.ui_param['Last time step end'])
self.last_step_end_edit.textChanged[str].connect(self.update_last_step)
# display current progress
multirun_progress = QLabel(
'User variable: , omit 0 of 0 files, 0 of 100 histogram files, 0% complete'
)
self.grid.addWidget(multirun_progress, 8, 0, 1, 12)
reset_slot(self.progress, multirun_progress.setText, True)
# table stores multirun values:
self.table = QTableWidget(self.nrows, self.ncols)
self.reset_array()
self.grid.addWidget(self.table, 9, 0, 20, 12)
scroll.setWidget(scroll_content)
#### #### array editing functions #### ####
def reset_array(self, newvals=None):
"""Empty the table of its values. If newvals are supplied then it
should have the right shape (rows, cols) so that it can be used
to fill the table items."""
self.table.setHorizontalHeaderLabels(list(map(str, range(self.ncols))))
if not newvals:
newvals = [[''] * self.ncols] * self.nrows
for i in range(self.table.rowCount()):
for j in range(self.ncols):
self.table.setItem(i, j, QTableWidgetItem())
self.table.item(i, j).setText(newvals[i][j])
def clear_array(self):
"""Empty the table of its values and reset the selected channels."""
self.reset_array()
self.ui_param['Type'] = ['Time step length'] * self.ncols
self.ui_param['Analogue type'] = ['Fast analogue'] * self.ncols
self.ui_param['Time step name'] = [[]] * self.ncols
self.ui_param['Analogue channel'] = [[]] * self.ncols
self.ui_param['list index'] = ['0'] * self.ncols
self.col_range_text = self.col_range_text[:self.ncols] + [''] * (
self.ncols - len(self.col_range_text))
self.set_chan_listbox(0)
def check_table(self):
"""Check that there are values in each of the cells of the array."""
try:
for i in range(self.table.rowCount()):
for j in range(self.table.columnCount()):
_ = float(self.table.item(i, j).text())
return 1
except ValueError:
return 0
def get_table(self):
"""Return a list of all the values in the multirun array table"""
return [[
self.table.item(i, j).text()
for j in range(self.table.columnCount())
] for i in range(self.table.rowCount())]
def change_array_size(self):
"""Update the size of the multirun array based on the number of rows
and columns specified in the line edit."""
self.nrows = int(self.rows_edit.text()) if self.rows_edit.text() else 1
if self.nrows < 1:
self.nrows = 1
self.table.setRowCount(self.nrows)
self.ncols = int(self.cols_edit.text()) if self.cols_edit.text() else 1
if self.ncols < 1:
self.ncols = 1
self.table.setColumnCount(self.ncols)
self.col_index.setValidator(QIntValidator(1, self.ncols - 1))
if self.col_index.text() and int(
self.col_index.text()) > self.ncols - 1:
self.col_index.setText(str(self.ncols - 1))
self.reset_array()
self.col_range_text = self.col_range_text[:self.ncols] + [''] * (
self.ncols - len(self.col_range_text))
self.ui_param['runs included'] = [[] for i in range(self.nrows)]
for key, default in zip([
'Type', 'Analogue type', 'Time step name', 'Analogue channel',
'list index'
], ['Time step length', 'Fast analogue', [], [], '0']):
for i in range(len(self.ui_param[key]), self.ncols):
self.ui_param[key].append(default)
if len(self.ui_param[key]) > self.ncols:
self.ui_param[key] = self.ui_param[key][:self.ncols]
def update_all_stats(self, toggle=False):
"""Shorthand to update the values of the stats dictionary from the text
labels."""
self.update_repeats()
self.update_last_step()
for key in self.measures.keys(
): # ['Variable label', 'measure', 'measure_prefix', '1st hist ID']
if self.measures[key].text(
): # don't do anything if the line edit is empty
try:
self.ui_param[key] = self.types[key](
self.measures[key].text())
except:
pass # probably while user was typing the '-' in '-1'
def update_repeats(self, txt=''):
"""Take the current values of the line edits and use them to set the
number of omitted and number of included runs in a histogram."""
self.ui_param['# omitted'] = int(
self.omit_edit.text()) if self.omit_edit.text() else 0
self.ui_param['# in hist'] = int(
self.nhist_edit.text()) if self.nhist_edit.text() else 1
def update_last_step(self, txt=''):
"""Save the current values of the last time step file paths."""
self.ui_param['Last time step run'] = self.last_step_run_edit.text()
self.ui_param['Last time step end'] = self.last_step_end_edit.text()
def apply_slice(self):
"""Use the text in the index slice line edit to select time steps"""
try:
self.chan_choices['Time step name'].clearSelection()
for i in eval(self.index_slice.text()):
try:
self.chan_choices['Time step name'].item(i).setSelected(
True)
except AttributeError:
pass # index out of range
self.save_chan_selection()
except (TypeError, ValueError, NameError) as e:
warning('Invalid selection command for multirun timesteps "' +
self.index_slice.text() + '".\n' + str(e))
def add_column_to_array(self):
"""Make a list of values and add it to the given column
in the multirun values array. The function is chosen by the user.
Values are repeated a set number of times, ordered according to the
ComboBox text. The selected channels are stored in lists."""
try: # make the list of values
table = np.array(self.get_table()).T
c = [column.astype(float) for column in table if '' not in column]
vals = eval(self.col_range.text())
except Exception as e:
warning('Add column to multirun: invalid syntax "' +
self.col_range.text() + '".\n' + str(e))
return 0
col = int(self.col_index.text()) if self.col_index.text() else 0
# store the selected channels
self.ui_param['Order'] = self.order_edit.currentText()
for key in self.measures.keys(
): # ['Variable label', 'measure', 'measure_prefix', '1st hist ID']
if self.measures[key].text(
): # don't do anything if the line edit is empty
self.ui_param[key] = self.types[key](self.measures[key].text())
# order the list of values
if self.ui_param['Order'] == 'descending':
vals = list(reversed(vals))
elif 'random' in self.ui_param['Order']:
vals = list(vals)
shuffle(vals)
for i in range(self.table.rowCount()):
try: # set vals in table cells
self.table.item(i, col).setText('%.4f' % vals[i])
except IndexError: # occurs if invalid range
self.table.item(i, col).setText('')
#### multirun channel selection ####
def reset_sequence(self, tr):
"""Update the translator object used to get the experimental sequence.
This is used to set the labels for time step names and channel names.
Note: the multirun sequence mrtr is not affected."""
self.tr = tr
self.change_mr_type(self.chan_choices['Type'].currentText())
# note: selected channels might have changed order
self.set_chan_listbox(self.col_index.text())
def save_chan_selection(self, arg=None):
"""When the user changes the selection of channels/timesteps for the
given column, save it. The selection will be reloaded if the user
changes the column and then comes back."""
try:
if self.col_index.text():
col = int(self.col_index.text())
for key in ['Type', 'Analogue type']:
self.ui_param[key][col] = self.chan_choices[
key].currentText()
for key in ['Time step name', 'Analogue channel']:
self.ui_param[key][col] = list(
map(self.chan_choices[key].row,
self.chan_choices[key].selectedItems()))
self.ui_param['list index'][col] = int(
self.list_index.text()) if self.list_index.text() else 0
self.col_range_text[col] = self.col_range.text()
except (ValueError, IndexError) as e:
error("Multirun couldn't save channel choices for column " +
self.col_index.text() + '.\n' + str(e))
def set_chan_listbox(self, col):
"""Set the selected channels and timesteps with the values
previously stored for the given column col. If there were
no values stored previously or the index is out of range,
reset the selection."""
try:
col = int(col) if col else 0
mrtype = self.ui_param['Type'][col]
antype = self.ui_param['Analogue type'][col]
sel = {
'Time step name':
self.ui_param['Time step name'][col],
'Analogue channel':
self.ui_param['Analogue channel'][col] if any(
mrtype == x for x in self.column_options) else []
}
list_ind = self.ui_param['list index'][col]
col_range_txt = self.col_range_text[col]
except (IndexError, ValueError):
mrtype, antype = 'Time step length', 'Fast analogue'
sel = {'Time step name': [], 'Analogue channel': []}
list_ind = 0
col_range_txt = ''
self.col_range.setText(col_range_txt)
self.list_index.setText(str(list_ind))
self.chan_choices['Type'].setCurrentText(mrtype)
self.chan_choices['Analogue type'].setCurrentText(antype)
self.chan_choices['Analogue channel'].setEnabled(
any(mrtype == x for x in self.column_options))
for key in ['Time step name', 'Analogue channel']:
self.chan_choices[key].setCurrentRow(
0, QItemSelectionModel.Clear) # clear previous selection
try:
for i in sel[key]: # select items at the stored indices
self.chan_choices[key].item(i).setSelected(True)
except IndexError:
pass # perhaps sequence was updated but using old selection indices
except AttributeError as e:
warning(
"Couldn't set channels for the loaded multirun parameters. Load the sequence first, then load multirun parameters.\n"
+ str(e))
def setListboxFlag(self, listbox, flag):
"""Set the items of the listbox all have the given flag.
e.g. self.setListboxFlag(self.chan_choices['Time step name'], ~Qt.ItemIsEditable)"""
for i in range(listbox.count()):
item = listbox.item(i)
item.setFlags(item.flags() | flag)
def get_anlg_chans(self, speed):
"""Return a list of name labels for the analogue channels.
speed -- 'Fast' or 'Slow'"""
chans = self.tr.get_esc()[5 if speed == 'Fast' else 10][2:]
return [c[2][1].text + ': ' + c[3][1].text for c in chans]
def change_mr_type(self, newtype):
"""Enable/Disable list boxes to reflect the multirun type:
newtype[str] -- Time step length: only needs timesteps
-- Analogue voltage: also needs channels
-- AWG: takes float values but with a list index."""
sht = self.tr.get_esc()[2][2:] # 'Sequence header top'
if newtype == 'AWG1 chan : seg' or newtype == 'AWG2 chan : seg':
self.chan_choices['Time step name'].clear()
self.chan_choices['Time step name'].addItems(
[str(i) + ', ' + str(j) for j in range(100) for i in range(2)])
reset_slot(
self.chan_choices['Analogue type'].currentTextChanged[str],
self.change_mr_anlg_type, False)
self.chan_choices['Analogue type'].clear()
self.chan_choices['Analogue type'].addItems(['AWG Parameter'])
self.chan_choices['Analogue channel'].setEnabled(True)
self.chan_choices['Analogue channel'].clear()
self.chan_choices['Analogue channel'].addItems(self.awg_args)
elif 'DDS' in newtype:
self.chan_choices['Time step name'].clear()
if 'DDS2' in newtype:
ddsoptions = [
'%s : P%s - ' % (i + 1, j) + self.COM2[i] for i in range(4)
for j in range(8)
]
for i in range(4):
ddsoptions.insert(i * 9 + 8,
'%s : aux - ' % (i + 1) + self.COM2[i])
else:
ddsoptions = [
'COM%s : P%s - ' % (i + 7, j) + self.COM[i]
for i in range(5) for j in range(8)
]
for i in range(5):
ddsoptions.insert(i * 9 + 8,
'COM%s : aux - ' % (i + 7) + self.COM[i])
self.chan_choices['Time step name'].addItems(ddsoptions)
reset_slot(
self.chan_choices['Analogue type'].currentTextChanged[str],
self.change_mr_anlg_type, False)
self.chan_choices['Analogue type'].clear()
self.chan_choices['Analogue type'].addItems(['DDS Parameter'])
self.chan_choices['Analogue channel'].setEnabled(True)
self.chan_choices['Analogue channel'].clear()
self.chan_choices['Analogue channel'].addItems(self.dds_args)
elif newtype == 'SLM holograms':
self.chan_choices['Time step name'].clear()
slmoptions = ['Hologram %s' % (i) for i in range(9)]
self.chan_choices['Time step name'].addItems(slmoptions)
reset_slot(
self.chan_choices['Analogue type'].currentTextChanged[str],
self.change_mr_anlg_type, False)
self.chan_choices['Analogue type'].clear()
self.chan_choices['Analogue type'].addItems(['Hologram Parameter'])
self.chan_choices['Analogue channel'].setEnabled(True)
self.chan_choices['Analogue channel'].clear()
self.chan_choices['Analogue channel'].addItems(self.slm_args)
else:
if any(self.chan_choices['Analogue type'].currentText() == x
for x in
['AWG Parameter', 'DDS Parameter', 'Hologram Parameter']):
self.chan_choices['Analogue type'].clear()
self.chan_choices['Analogue type'].addItems(
['Fast analogue', 'Slow analogue'])
self.chan_choices['Analogue type'].currentTextChanged[
str].connect(self.change_mr_anlg_type)
if newtype == 'Other':
self.chan_choices['Analogue channel'].setEnabled(False)
self.chan_choices['Time step name'].clear()
self.chan_choices['Time step name'].addItems(['Variable'])
elif newtype == 'Time step length':
self.chan_choices['Analogue channel'].setEnabled(False)
self.chan_choices['Time step name'].clear()
self.chan_choices['Time step name'].addItems(
list(
map(str.__add__, [str(i) for i in range(len(sht))],
[': ' + hc[6][1].text
for hc in sht]))) # time step names
elif newtype == 'Analogue voltage':
self.chan_choices['Time step name'].clear()
self.chan_choices['Time step name'].addItems(
list(
map(str.__add__, [str(i) for i in range(len(sht))],
[': ' + hc[6][1].text
for hc in sht]))) # time step names
self.chan_choices['Analogue channel'].setEnabled(True)
self.chan_choices['Analogue channel'].clear()
self.chan_choices['Analogue channel'].addItems(
self.get_anlg_chans(
self.chan_choices['Analogue type'].currentText().split(
' ')[0]))
def change_mr_anlg_type(self, newtype):
"""Change the analogue channels listbox when fast/slow
analogue channels are selected."""
if self.chan_choices['Analogue channel'].isEnabled():
self.chan_choices['Analogue channel'].clear()
self.chan_choices['Analogue channel'].addItems(
self.get_anlg_chans(
self.chan_choices['Analogue type'].currentText().split(
' ')[0]))
def get_next_index(self, rn):
"""Choose the next index from the rows of the table to use
in the multirun, based on the order chosen.
rn: the ID of the current run within the multirun.
make rn modulo nrows so that there isn't an index error on the last run."""
# if self.mr_param['Order'] == 'unsorted':
# return rn % self.nrows
# elif self.mr_param['Order'] == 'random':
# return randint(0, self.nrows - 1)
# else: # if descending, ascending, or coarse random, the order has already been set
return (rn // (self.mr_param['# omitted'] + self.mr_param['# in hist'])
) % len(self.mr_param['runs included']
) # ID of histogram in repetition cycle
def get_next_sequence(self, i=None):
"""Use the values in the multirun array to make the next
sequence to run in the multirun. Uses saved mr_param not UI"""
if i == None: i = self.ind # row index
esc = self.mrtr.get_esc() # shorthand
num_s = len(esc[2]) - 2 # number of steps
try:
for col in range(len(self.mr_vals[i])): # edit the sequence
try:
val = float(self.mr_vals[i][col])
if self.mr_param['Type'][col] == 'Time step length':
for head in [2, 9]:
for t in self.mr_param['Time step name'][col]:
esc[head][t + 2][3][1].text = str(val)
elif self.mr_param['Type'][col] == 'Analogue voltage':
for t in self.mr_param['Time step name'][col]:
for c in self.mr_param['Analogue channel'][col]:
if 'Fast' in self.mr_param['Analogue type'][
col]:
esc[6][t + c * num_s +
3][3][1].text = str(val)
else:
esc[11][t + c * num_s +
3][3][1].text = str(val)
except ValueError as e:
pass # non-float variable
self.mrtr.set_routine_name('Multirun ' + self.mr_param['Variable label'] + \
': ' + self.mr_vals[i][0] + ' (%s / %s)'%(i+1, len(self.mr_vals)))
except IndexError as e:
error('Multirun failed to edit sequence at ' +
self.mr_param['Variable label'] + ' = ' +
self.mr_vals[i][0] + '\n' + str(e))
return self.mrtr.write_to_str()
def get_all_sequences(self, save_dir=''):
"""Use the multirun array vals to make all of
the sequences that will be used in the multirun, then
store these as a list of XML strings."""
self.msglist = []
for i in range(len(self.mr_vals)):
self.msglist.append(self.get_next_sequence(i))
if not self.ss.isRunning():
self.ss = sequenceSaver(self.mrtr, self.mr_vals, self.mr_param,
save_dir)
self.ss.start(self.ss.LowestPriority) # save the sequences
else: # a backup if the first is busy saving sequences
self.s2 = sequenceSaver(self.mrtr, self.mr_vals, self.mr_param,
save_dir)
self.s2.start(self.s2.LowestPriority)
#### save and load parameters ####
def view_mr_queue(self):
"""Show the window for editing the multirun queue"""
self.queue_ui.updateList()
self.QueueWindow.show()
def try_browse(self,
title='Select a File',
file_type='all (*)',
open_func=QFileDialog.getOpenFileName):
"""Open a file dialog and retrieve a file name from the browser.
title: String to display at the top of the file browser window
file_type: types of files that can be selected
open_func: the function to use to open the file browser"""
try:
if 'PyQt4' in sys.modules:
file_name = open_func(self, title, '', file_type)
elif 'PyQt5' in sys.modules:
file_name, _ = open_func(self, title, '', file_type)
return file_name
except OSError:
return '' # probably user cancelled
def save_mr_params(self, save_file_name=''):
"""Save the variable label, measure, measure prefix, # runs omitted,
# runs per histogram, multirun type, list of timesteps, multirun
# analogue type, list of channels, and array of variables."""
if not save_file_name:
save_file_name = self.try_browse(
title='Save File',
file_type='csv(*.csv);;all (*)',
open_func=QFileDialog.getSaveFileName)
if save_file_name:
if hasattr(self.sender(),
'text') and self.sender().text() == 'Save Parameters':
params, vals = self.ui_param, self.get_table() # save from UI
else:
params, vals = self.mr_param, self.mr_vals # save from multirun
try:
with open(save_file_name, 'w+') as f:
f.write('Multirun list of variables:\n')
f.write(';'.join([
','.join(
[vals[row][col] for col in range(len(vals[0]))])
for row in range(len(vals))
]) + '\n')
f.write(';'.join(params.keys()) + '\n')
f.write(';'.join(map(str, list(params.values()))))
except (PermissionError, FileNotFoundError) as e:
error("Couldn't save Multirun params to file: %s\n" %
save_file_name + str(e))
def load_mr_params(self, load_file_name=''):
"""Load the multirun variables array from a file."""
if not load_file_name:
load_file_name = self.try_browse(
title='Load File',
file_type='csv(*.csv);;all (*)',
open_func=QFileDialog.getOpenFileName)
if load_file_name:
with open(load_file_name, 'r') as f:
_ = f.readline()
vals = [
x.split(',')
for x in f.readline().replace('\n', '').split(';')
]
header = f.readline().replace('\n', '').split(';')
params = f.readline().split(';')
for i in range(len(header)):
if header[i] in self.ui_param:
try:
self.ui_param[header[i]] = self.types[header[i]](
params[i])
except ValueError as e:
error(
'Multirun editor could not load parameter: %s\n' %
params[i] + str(e))
# store values in case they're overwritten after setText()
nrows, ncols = np.shape(vals) # update array of values
col = int(self.col_index.text()) if self.col_index.text() else 0
nhist, nomit = map(
str, [self.ui_param['# in hist'], self.ui_param['# omitted']])
runstep, endstep = self.ui_param[
'Last time step run'], self.ui_param['Last time step end']
# then update the label edits
for key in self.measures.keys(
): # update variable label and measure
reset_slot(self.measures[key].textChanged,
self.update_all_stats, False)
self.measures[key].setText(str(self.ui_param[key]))
reset_slot(self.measures[key].textChanged,
self.update_all_stats, True)
self.set_chan_listbox(col if col < ncols else 0)
self.rows_edit.setText(str(nrows)) # triggers change_array_size
self.cols_edit.setText(str(ncols))
self.change_array_size() # don't wait for it to be triggered
self.reset_array(vals)
self.nhist_edit.setText(nhist)
self.omit_edit.setText(nomit)
self.last_step_run_edit.setText(
runstep) # triggers update_last_step
self.last_step_end_edit.setText(endstep)
for i in range(
len(header)
): # restore values as change_array_size loads defaults
if header[i] in self.ui_param:
try:
self.ui_param[header[i]] = self.types[header[i]](
params[i])
except ValueError as e:
pass
def check_mr_params(self, save_results_path='.'):
"""Check that the multirun parameters are valid before adding it to the queue"""
if 'PyDex default empty sequence' in self.tr.get_routine_name():
QMessageBox.warning(
self, 'No sequence loaded',
'You must load a sequence before starting a multirun.')
return 0
results_path = os.path.join(save_results_path,
self.ui_param['measure_prefix'])
self.appending = False
# first check if the measure folder already exists with some files in
imax = -1
try:
filelist = os.listdir(results_path)
for fname in filelist:
if 'params' in fname:
try: # look for multirun parameters file
with open(os.path.join(results_path, fname), 'r') as f:
_ = f.readline()
vals = f.readline().replace('\n', '').split(';')
header = f.readline().replace('\n', '').split(';')
params = f.readline().split(';')
imax = max(
imax,
len(vals) +
int(params[header.index('1st hist ID')]) - 1)
except:
pass
except (FileNotFoundError, PermissionError):
pass
# then check the multirun queue
for m in self.mr_queue:
if self.ui_param['measure_prefix'] == m[0]['measure_prefix']:
imax = max(imax, len(m[2]) + m[0]['1st hist ID'] - 1)
if self.ui_param['1st hist ID'] == -1: # append at the end
self.appending = True
self.ui_param['1st hist ID'] = imax + 1 if imax >= 0 else 0
if (os.path.isdir(results_path) or self.ui_param['measure_prefix'] in [
x[0]['measure_prefix'] for x in self.mr_queue
]) and imax >= self.ui_param['1st hist ID']:
# this measure exists, check if user wants to overwrite
reply = QMessageBox.question(
self, 'Confirm Overwrite',
"Results path already exists, do you want to overwrite the csv and dat files?\n"
+ results_path, QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if reply == QMessageBox.No:
if self.appending: # if appending, reset ui_param to -1. Also happens at end of multirun in runid.py
self.measures['1st hist ID'].setText('')
self.measures['1st hist ID'].setText('-1')
return 0
# elif reply == QMessageBox.Yes:
# try:
# for fn in os.listdir(results_path):
# if '.csv' in fn or '.dat' in fn:
# os.remove(os.path.join(results_path, fn))
# except Exception as e:
# warning('Multirun could not remove files from '+results_dir+'\n'+str(e))
# parameters are valid, add to queue
self.mr_queue.append([
copy.deepcopy(self.ui_param),
self.tr.copy(),
self.get_table(), self.appending
])
if self.appending: # if appending, reset ui_param to -1. Also happens at end of multirun in runid.py
self.measures['1st hist ID'].setText('')
self.measures['1st hist ID'].setText('-1')
if self.suggest_button.isChecked(
): # suggest new multirun measure ID and prefix
n = self.ui_param['measure'] + 1
self.measures['measure'].setText(str(n))
self.measures['measure_prefix'].setText('Measure' + str(n))
return 1
class NewRelationDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(self.tr("Nueva Relación"))
vbox = QVBoxLayout(self)
hbox = QHBoxLayout()
self._line_relation_name = QLineEdit()
hbox.addWidget(QLabel(self.tr("Nombre:")))
hbox.addWidget(self._line_relation_name)
vbox.addLayout(hbox)
vbox.addWidget(QLabel(
self.tr("La primera fila corresponde a los campos")))
hbox = QHBoxLayout()
btn_add_column = QPushButton(self.tr("Agregar Columna"))
hbox.addWidget(btn_add_column)
btn_add_tuple = QPushButton(self.tr("Agregar Tupla"))
hbox.addWidget(btn_add_tuple)
btn_remove_column = QPushButton(self.tr("Eliminar Columna"))
hbox.addWidget(btn_remove_column)
btn_remove_tuple = QPushButton(self.tr("Eliminar Tupla"))
hbox.addWidget(btn_remove_tuple)
vbox.addLayout(hbox)
self._table = QTableWidget()
vbox.addWidget(self._table)
self._table.setRowCount(1)
self._table.setColumnCount(2)
self._table.setItem(0, 0, QTableWidgetItem("Campo 1"))
self._table.setItem(0, 1, QTableWidgetItem("Campo 2"))
hbox = QHBoxLayout()
hbox.addItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
btn_ok = QPushButton(self.tr("Aceptar"))
hbox.addWidget(btn_ok)
btn_cancel = QPushButton(self.tr("Cancelar"))
hbox.addWidget(btn_cancel)
vbox.addLayout(hbox)
# Connections
self.connect(btn_add_column, SIGNAL("clicked()"),
self.__add_column)
self.connect(btn_remove_column, SIGNAL("clicked()"),
self.__remove_column)
self.connect(btn_add_tuple, SIGNAL("clicked()"),
self.__add_tuple)
self.connect(btn_remove_tuple, SIGNAL("clicked()"),
self.__remove_tuple)
self.connect(btn_ok, SIGNAL("clicked()"),
self.__create_table)
self.connect(btn_cancel, SIGNAL("clicked()"),
self.close)
def __add_column(self):
columns = self._table.columnCount()
self._table.insertColumn(columns)
def __remove_column(self):
current = self._table.currentColumn()
self._table.removeColumn(current)
def __add_tuple(self):
tuples = self._table.rowCount()
self._table.insertRow(tuples)
def __remove_tuple(self):
current = self._table.currentRow()
self._table.removeRow(current)
def __create_table(self):
name = self._line_relation_name.text()
rows = self._table.rowCount()
columns = self._table.columnCount()
rel = relation.Relation()
fields = [self._table.item(0, i).text() for i in range(columns)]
rel.fields = fields
data = {}
for row in range(1, rows):
reg = []
for column in range(columns):
reg.append(self._table.item(row, column).text())
data[row, column] = self._table.item(row, column).text()
rel.insert(reg)
table_widget = Pireal.get_service("container").table_widget
table_widget.add_table(rows - 1, columns, name, data)
#table_widget.relations[name] = rel
self.close()
class RemoveSentencesDlg(QDialog):
def __init__(self):
super(RemoveSentencesDlg, self).__init__()
self.removeList = {}
self.initUI()
def initUI(self):
## create a font type for the label
fontLabel = QFont('SansSerif', 14)
## create a label
self.label = QLabel(self)
self.label.setAutoFillBackground(True)
self.label.setAlignment(Qt.AlignCenter)
self.label.setGeometry(QRect(200, 10, 400, 40))
self.label.setFont(fontLabel)
## set the text for the Label
self.label.setText('Remove the Sentences')
## Create a Table to hold all the sentences
self.sentenceTable = QTableWidget(self)
## set the size and the position of the table
self.sentenceTable.setGeometry(QRect(10, 60, 800, 400))
## set the column count for the table
self.sentenceTable.setColumnCount(1)
sentenceHeaderList = ['Sentences From Table']
self.sentenceTable.setHorizontalHeaderLabels(sentenceHeaderList)
self.sentenceTable.resizeColumnsToContents()
self.sentenceTable.horizontalHeader().setStretchLastSection(True)
self.sentenceTable.verticalHeader().setStretchLastSection(True)
# Create a Remove button
self.removeButton = QPushButton('Remove', self)
self.removeButton.move(350, 600)
# Create a close button
self.closeButton = QPushButton('Close', self)
self.closeButton.move(450, 600)
## Create signal for the remove button
self.connect(self.removeButton, SIGNAL("clicked()"), self.onRemoveClicked)
## Create signal for the close button
self.connect(self.closeButton, SIGNAL("clicked()"), self.closeClicked)
## Create signal for the sentence table
self.connect(self.sentenceTable, SIGNAL('cellClicked(int, int)'), self.sentenceStateChanged)
## Get sentences from the database table
self.getSentencesFromDatabase()
self.setGeometry(800, 800, 900, 650)
def getSentencesFromDatabase(self):
## returns the sentence and the corresponding word associated with it
self.twoTypeList = data.Data().getSentencesFromDatabase()
if len(self.twoTypeList) == 2:
self.sentenceList = self.twoTypeList[0]
## load the sentences in the Table Widget
self.loadSentencesInTable()
def loadSentencesInTable(self):
self.col = 0
if len(self.sentenceList) > 0:
self.sentenceTable.setRowCount(len(self.sentenceList))
cellList = []
## Create QTableWidgetItems from the sentence list
for sentence in self.sentenceList:
item = QTableWidgetItem(QString(sentence))
item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled))
item.setCheckState(Qt.Unchecked)
cellList.append(item)
cellList.reverse()
# set the widget items in the table
for item in range(0, len(self.sentenceList)):
self.sentenceTable.setItem(item, self.col, cellList.pop())
for index in range(0, len(self.sentenceList)):
self.sentenceTable.verticalHeader().resizeSection(index, 100)
if len(self.sentenceList) == 5:
self.sentenceTable.setFixedHeight(500)
if len(self.sentenceList) == 4:
self.sentenceTable.setFixedHeight(400)
elif len(self.sentenceList) == 3:
self.sentenceTable.setFixedHeight(300)
elif len(self.sentenceList) == 2:
self.sentenceTable.setFixedHeight(200)
elif len(self.sentenceList) == 1:
self.sentenceTable.setFixedHeight(100)
else:
self.sentenceTable.clearContents()
def sentenceStateChanged(self, row, col):
if (self.sentenceTable.item(row, col).checkState() == 2):
self.removeList[row] = self.sentenceTable.item(row, col).text()
self.sentenceTable.item(row, col).setFlags(Qt.ItemFlags(Qt.ItemIsEditable |
Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable))
else:
self.sentenceTable.item(row,col).setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled))
del self.removeList[row]
def onRemoveClicked(self):
if len(self.removeList) == 0:
QMessageBox.information(self, 'Remove Sentences',
'Select the Sentences to Delete')
else:
reply = QMessageBox.question(self,
'Remove Sentences',
'You want to delete the selected sentences',
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
for sentence in self.removeList:
if sentence in self.sentenceList:
self.sentenceList.remove(sentence)
## clear the contents of the Table
self.sentenceTable.clearContents()
cellList = []
## Add the new entries into the table
for sentence in self.sentenceList:
item = QTableWidgetItem(QString(sentence))
item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled))
item.setCheckState(Qt.Unchecked)
cellList.append(item)
cellList.reverse()
for index in range(0, len(self.sentenceList)):
self.sentenceTable.setItem(index, self.col, cellList.pop())
self.sentenceTable.setRowCount(len(self.sentenceList))
deleteSentences = []
for sentence in self.removeList.values():
deleteSentences.append(sentence)
rowsDeletec = data.Data().deleteSentencesFromDatabase(deleteSentences)
self.getSentencesFromDatabase()
self.removeList = {}
def closeClicked(self):
reply = QMessageBox.question(self,
"Remove Sentences",
"Do you want to close the application",
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
self.reject()
class KeywordTable(HelpedWidget):
"""Shows a table of key/value pairs. The data structure expected and sent to the getter and setter is a dictionary of values."""
def __init__(self, model, table_label="", help_link=""):
HelpedWidget.__init__(self, table_label, help_link)
self.table = QTableWidget(self)
self.table.setColumnCount(2)
self.setColumnHeaders()
self.table.verticalHeader().setHidden(True)
self.table.setColumnWidth(0, 150)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.setMinimumHeight(110)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.addWidget(self.table)
self.addWidget(AddRemoveWidget(self.addItem, self.removeItem))
self.connect(self.table, SIGNAL('cellChanged(int,int)'), self.tableChanged)
assert isinstance(model, DictionaryModelMixin)
self.model = model
model.observable().attach(DictionaryModelMixin.DICTIONARY_CHANGED_EVENT, self.modelChanged)
self.modelChanged()
def setColumnHeaders(self, keyword_name="Keyword", value_name="Value"):
self.headers = [keyword_name, value_name]
self.table.setHorizontalHeaderLabels(self.headers)
def addItem(self):
"""Called by the add button to insert a new keyword"""
title = "New %s" % self.headers[0]
description = "Enter new %s:" % self.headers[0]
(new_keyword, ok) = QInputDialog.getText(self, title, description, QLineEdit.Normal)
if ok:
new_keyword = str(new_keyword).strip()
self.model.addKey(new_keyword)
def removeItem(self):
"""Called by the remove button to remove a selected keyword"""
current_row = self.table.currentRow()
if current_row >= 0:
do_delete = QMessageBox.question(self, "Delete row?", "Are you sure you want to delete the key/value pair?", QMessageBox.Yes | QMessageBox.No )
if do_delete:
key_item = self.table.item(current_row, 0)
if key_item is not None:
key = str(key_item.text()).strip()
self.model.removeKey(key)
def tableChanged(self, row, column):
"""Called whenever the contents of a cell changes."""
key_item = self.table.item(row, 0)
if key_item is not None:
key = str(key_item.text()).strip()
value_item = self.table.item(row, 1)
if value_item is not None:
value = str(value_item.text()).strip()
self.model.setValueForKey(key, value)
def modelChanged(self):
"""Retrieves data from the model and inserts it into the table."""
values = self.model.getDictionary()
blocked = self.table.blockSignals(True)
for row in reversed(range(self.table.rowCount())):
self.table.removeRow(row)
row = 0
for key in values:
key_item = QTableWidgetItem(str(key))
key_item.setFlags(key_item.flags() ^ Qt.ItemIsEditable)
value_item = QTableWidgetItem(str(values[key]))
self.table.insertRow(row)
self.table.setItem(row, 0, key_item)
self.table.setItem(row, 1, value_item)
row += 1
self.table.blockSignals(blocked)
class OWxsh_waviness(widget.OWWidget):
name = "xsh_waviness"
id = "orange.widgets.preprocessor.xsh_waviness"
description = "xoppy application to compute..."
icon = "icons/waviness.png"
author = "Luca Rebuffi"
maintainer_email = "[email protected]; [email protected]"
priority = 10
category = ""
keywords = ["xoppy", "xsh_waviness"]
outputs = [{"name": "PreProcessor_Data",
"type": ShadowPreProcessorData,
"doc": "PreProcessor Data",
"id": "PreProcessor_Data"}]
want_main_area = 1
want_control_area = 1
WIDGET_WIDTH = 1100
WIDGET_HEIGHT = 650
xx = None
yy = None
zz = None
number_of_points_x = Setting(10)
number_of_points_y = Setting(100)
dimension_x = Setting(20.1)
dimension_y = Setting(113.1)
estimated_slope_error = Setting(0.9)
montecarlo_seed = Setting(2387427)
waviness_file_name = Setting('waviness.dat')
harmonic_maximum_index = Setting(60)
data = Setting({'c': ['0.3',
'0.1',
'0.1',
'0.0',
'0.0',
'0.0',
'0.3',
'0.0',
'0.0',
'0.3',
'0.0',
'0.0',
'0.5',
'0.0',
'0.0',
'0.2',
'0.2',
'0.2',
'0.9',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.4',
'0.0',
'0.0',
'0.4',
'0.0',
'0.0',
'0.0',
'0.6',
'0.6',
'0.0',
'0.4',
'0.4',
'0.0',
'0.4',
'0.4',
'0.1',
'0.4',
'0.4',
'0.1',
'0.2',
'0.2',
'0.0',
'0.2',
'0.2',
'0.0',
'0.3',
'0.3',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0'],
'y': ['0.0',
'-0.1',
'-0.1',
'0.0',
'0.0',
'0.0',
'0.03',
'0.0',
'0.0',
'0.2',
'0.0',
'0.0',
'0.2',
'0.0',
'0.0',
'0.1',
'0.1',
'0.1',
'0.1',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.01',
'0.0',
'0.0',
'0.03',
'0.0',
'0.0',
'0.0',
'0.02',
'0.02',
'0.0',
'0.1',
'0.1',
'0.0',
'0.1',
'0.1',
'0.0',
'0.1',
'0.1',
'0.0',
'0.0',
'0.0',
'0.0',
'0.3',
'0.3',
'0.0',
'0.2',
'0.2',
'0.0',
'0.2',
'0.2',
'0.0',
'0.2',
'0.2',
'0.0',
'0.0',
'0.0',
'0.0'],
'g': ['0.0',
'0.3',
'0.3',
'0.0',
'0.0',
'0.0',
'0.05',
'0.0',
'0.0',
'0.05',
'0.0',
'0.0',
'0.1',
'0.0',
'0.0',
'0.05',
'0.05',
'0.05',
'0.2',
'0.0',
'0.0',
'0.0',
'0.0',
'0.0',
'0.1',
'0.0',
'0.0',
'0.1',
'0.0',
'0.0',
'0.0',
'0.2',
'0.2',
'0.0',
'0.1',
'0.1',
'0.0',
'0.1',
'0.1',
'0.0',
'0.1',
'0.1',
'0.0',
'0.0',
'0.0',
'0.0',
'0.1',
'0.1',
'0.0',
'0.2',
'0.2',
'0.0',
'0.1',
'0.1',
'0.0',
'0.1',
'0.1',
'0.0',
'0.0',
'0.0',
'0.0']})
def __init__(self):
super().__init__()
geom = QApplication.desktop().availableGeometry()
self.setGeometry(QRect(round(geom.width() * 0.05),
round(geom.height() * 0.05),
round(min(geom.width() * 0.98, self.WIDGET_WIDTH)),
round(min(geom.height() * 0.95, self.WIDGET_HEIGHT))))
gen_box = ShadowGui.widgetBox(self.controlArea, "Waviness Parameters", addSpace=True, orientation="horizontal",
width=500)
tabs_setting = gui.tabWidget(gen_box)
tab_input = ShadowGui.createTabPage(tabs_setting, "Input Parameter")
tab_harmonics = ShadowGui.createTabPage(tabs_setting, "Harmonics")
tab_out = ShadowGui.createTabPage(tabs_setting, "Output")
self.input_box = ShadowGui.widgetBox(tab_input, "Inputs", addSpace=True, orientation="vertical", width=470)
gui.button(self.input_box, self, "Load xsh_waviness input file ...", callback=self.load_inp_file)
gui.separator(self.input_box)
ShadowGui.lineEdit(self.input_box, self, "number_of_points_x", "Number of Points (<201) X (width)",
labelWidth=300, valueType=int, orientation="horizontal")
ShadowGui.lineEdit(self.input_box, self, "number_of_points_y",
" Y (length)", labelWidth=300, valueType=int,
orientation="horizontal")
gui.separator(self.input_box)
ShadowGui.lineEdit(self.input_box, self, "dimension_x", "Dimensions [cm] X (width)",
labelWidth=300, valueType=float, orientation="horizontal")
ShadowGui.lineEdit(self.input_box, self, "dimension_y",
" Y (length)", labelWidth=300,
valueType=float, orientation="horizontal")
gui.separator(self.input_box)
ShadowGui.lineEdit(self.input_box, self, "estimated_slope_error", "Estimated slope error [arcsec]",
labelWidth=300, valueType=float, orientation="horizontal")
ShadowGui.lineEdit(self.input_box, self, "montecarlo_seed", "Monte Carlo initial seed", labelWidth=300,
valueType=int, orientation="horizontal")
self.output_box = ShadowGui.widgetBox(tab_input, "Outputs", addSpace=True, orientation="vertical", width=470)
self.select_file_box = ShadowGui.widgetBox(self.output_box, "", addSpace=True, orientation="horizontal")
gui.separator(self.output_box)
gui.button(self.output_box, self, "Write xsh_waviness input file (optional) ...", callback=self.write_inp_file)
ShadowGui.lineEdit(self.select_file_box, self, "waviness_file_name", "Output File Name", labelWidth=120,
valueType=str, orientation="horizontal")
self.harmonics_box = ShadowGui.widgetBox(tab_harmonics, "Harmonics", addSpace=True, orientation="vertical",
width=470, height=690)
ShadowGui.lineEdit(self.harmonics_box, self, "harmonic_maximum_index", "Harmonic Maximum Index", labelWidth=300,
valueType=int, orientation="horizontal", callback=self.set_harmonics)
gui.separator(self.harmonics_box)
self.scrollarea = QScrollArea()
self.scrollarea.setMaximumWidth(400)
self.harmonics_box.layout().addWidget(self.scrollarea, alignment=Qt.AlignHCenter)
self.shadow_output = QTextEdit()
self.shadow_output.setReadOnly(True)
out_box = ShadowGui.widgetBox(tab_out, "System Output", addSpace=True, orientation="horizontal", height=600)
out_box.layout().addWidget(self.shadow_output)
button_box = ShadowGui.widgetBox(self.controlArea, "", addSpace=False, orientation="horizontal")
button = gui.button(button_box, self, "Calculate Waviness", callback=self.calculate_waviness)
button.setFixedHeight(45)
button.setFixedWidth(170)
button = gui.button(button_box, self, "Generate Waviness File", callback=self.generate_waviness_file)
font = QFont(button.font())
font.setBold(True)
button.setFont(font)
palette = QPalette(button.palette()) # make a copy of the palette
palette.setColor(QPalette.ButtonText, QColor('Dark Blue'))
button.setPalette(palette) # assign new palette
button.setFixedHeight(45)
button.setFixedWidth(200)
button = gui.button(button_box, self, "Reset Fields", callback=self.call_reset_settings)
font = QFont(button.font())
font.setItalic(True)
button.setFont(font)
palette = QPalette(button.palette()) # make a copy of the palette
palette.setColor(QPalette.ButtonText, QColor('Dark Red'))
button.setPalette(palette) # assign new palette
button.setFixedHeight(45)
button.setFixedWidth(120)
gui.rubber(self.controlArea)
self.figure = Figure(figsize=(600, 600))
self.figure.patch.set_facecolor('white')
self.axis = self.figure.add_subplot(111, projection='3d')
self.axis.set_xlabel("X (cm)")
self.axis.set_ylabel("Y (cm)")
self.axis.set_zlabel("Z (µm)")
self.figure_canvas = FigureCanvasQTAgg(self.figure)
self.mainArea.layout().addWidget(self.figure_canvas)
gui.rubber(self.mainArea)
def restoreWidgetPosition(self):
super().restoreWidgetPosition()
self.table = QTableWidget(self.harmonic_maximum_index + 1, 3)
self.table.setAlternatingRowColors(True)
self.table.horizontalHeader().setResizeMode(QHeaderView.Fixed)
for i in range(0, 3):
self.table.setColumnWidth(i, 70)
horHeaders = []
verHeaders = []
for n, key in enumerate(sorted(self.data.keys())):
horHeaders.append(key)
for m, item in enumerate(self.data[key]):
table_item = QTableWidgetItem(str(item))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(m, n, table_item)
verHeaders.append(str(m))
self.table.setHorizontalHeaderLabels(horHeaders)
self.table.setVerticalHeaderLabels(verHeaders)
self.table.resizeRowsToContents()
self.table.itemChanged.connect(self.table_item_changed)
self.scrollarea.setWidget(self.table)
self.scrollarea.setWidgetResizable(1)
gui.rubber(self.controlArea)
def reload_harmonics_table(self):
horHeaders = []
verHeaders = []
self.table.itemChanged.disconnect(self.table_item_changed)
self.table.clear()
row_count = self.table.rowCount()
for n in range(0, row_count):
self.table.removeRow(0)
for index in range(0, self.harmonic_maximum_index + 1):
self.table.insertRow(0)
for n, key in enumerate(sorted(self.data.keys())):
horHeaders.append(key)
for m, item in enumerate(self.data[key]):
table_item = QTableWidgetItem(str(item))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(m, n, table_item)
verHeaders.append(str(m))
self.table.setHorizontalHeaderLabels(horHeaders)
self.table.setVerticalHeaderLabels(verHeaders)
self.table.resizeRowsToContents()
for i in range(0, 3):
self.table.setColumnWidth(i, 70)
self.table.itemChanged.connect(self.table_item_changed)
def table_item_changed(self):
dict = {}
message = ""
error_row_index = -1
error_column_index = -1
previous_value = ""
try:
row_count = self.harmonic_maximum_index + 1
for column_index in range(0, self.table.columnCount()):
column_name = self.table.horizontalHeaderItem(column_index).data(0)
row_content = []
for row_index in range(0, row_count):
if not self.table.item(row_index, column_index) is None:
message = "Value at row " + str(
row_index) + " and column \'" + column_name + "\' is not numeric"
error_row_index = row_index
error_column_index = column_index
previous_value = self.data[column_name][row_index]
value = float(self.table.item(row_index, column_index).data(0)) # to raise exception
row_content.append(str(value))
dict[column_name] = row_content
self.data = dict
except ValueError:
QMessageBox.critical(self, "QMessageBox.critical()",
message + "\nValue is reset to previous value",
QMessageBox.Ok)
table_item = QTableWidgetItem(previous_value)
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(error_row_index, error_column_index, table_item)
self.table.setCurrentCell(error_row_index, error_column_index)
except Exception as exception:
QMessageBox.critical(self, "QMessageBox.critical()",
exception.args[0],
QMessageBox.Ok)
def set_harmonics(self):
if self.harmonic_maximum_index < 0:
QMessageBox.critical(self, "QMessageBox.critical()",
"Harmonic Maximum Index should be a positive integer number",
QMessageBox.Ok)
else:
row_count = len(self.data["c"])
if self.harmonic_maximum_index + 1 > row_count:
for n, key in enumerate(sorted(self.data.keys())):
for m in range(row_count, self.harmonic_maximum_index + 1):
self.data[key].append('0.0')
else:
for n, key in enumerate(sorted(self.data.keys())):
self.data[key] = copy.deepcopy(self.data[key][0: self.harmonic_maximum_index + 1])
self.reload_harmonics_table()
def load_inp_file(self):
file_name = QFileDialog.getOpenFileName(self, "Select a input file for XSH_WAVINESS", ".", "*.inp")
if not file_name is None:
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
if not file_name.strip() == "":
dict = ST.waviness_read(file=file_name)
self.number_of_points_x = dict["npointx"]
self.number_of_points_y = dict["npointy"]
self.dimension_y = dict["xlength"]
self.dimension_x = dict["width"]
self.estimated_slope_error = dict["slp"]
self.montecarlo_seed = dict["iseed"]
self.waviness_file_name = dict["file"].strip('\n\r').strip()
self.harmonic_maximum_index = dict["nharmonics"]
self.data["c"] = self.to_str_array(dict["c"])
self.data["y"] = self.to_str_array(dict["y"])
self.data["g"] = self.to_str_array(dict["g"])
self.reload_harmonics_table()
def write_inp_file(self):
try:
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.check_fields()
file_name = self.waviness_file_name.strip().split(sep=".dat")[0] + ".inp"
dict = {}
dict["npointx"] = self.number_of_points_x
dict["npointy"] = self.number_of_points_y
dict["xlength"] = self.dimension_y
dict["width"] = self.dimension_x
dict["slp"] = self.estimated_slope_error
dict["iseed"] = self.montecarlo_seed
dict["file"] = self.waviness_file_name.strip('\n\r')
dict["nharmonics"] = self.harmonic_maximum_index
dict["c"] = self.to_float_array(self.data["c"])
dict["y"] = self.to_float_array(self.data["y"])
dict["g"] = self.to_float_array(self.data["g"])
ST.waviness_write(dict, file=file_name)
QMessageBox.information(self, "QMessageBox.information()",
"File \'" + file_name + "\' written to disk",
QMessageBox.Ok)
except Exception as exception:
QMessageBox.critical(self, "QMessageBox.critical()",
exception.args[0],
QMessageBox.Ok)
def calculate_waviness(self):
try:
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.check_fields()
xx, yy, zz = ST.waviness_calc(npointx=self.number_of_points_x,
npointy=self.number_of_points_y,
width=self.dimension_x,
xlength=self.dimension_y,
slp=self.estimated_slope_error,
nharmonics=self.harmonic_maximum_index,
iseed=self.montecarlo_seed,
c=self.to_float_array(self.data["c"]),
y=self.to_float_array(self.data["y"]),
g=self.to_float_array(self.data["g"]))
self.xx = xx
self.yy = yy
self.zz = zz
self.axis.clear()
x_to_plot, y_to_plot = numpy.meshgrid(xx, yy)
z_to_plot = []
for y_index in range(0, len(yy)):
z_array = []
for x_index in range(0, len(xx)):
z_array.append(1e4 * float(zz[x_index][y_index])) # to micron
z_to_plot.append(z_array)
z_to_plot = numpy.array(z_to_plot)
self.axis.plot_surface(x_to_plot, y_to_plot, z_to_plot,
rstride=1, cstride=1, cmap=cm.autumn, linewidth=0.5, antialiased=True)
slope, sloperms = ST.slopes(zz, xx, yy)
title = ' Slope error rms in X direction: %f arcsec' % (sloperms[0]) + '\n' + \
' : %f urad' % (sloperms[2]) + '\n' + \
' Slope error rms in Y direction: %f arcsec' % (sloperms[1]) + '\n' + \
' : %f urad' % (sloperms[3])
self.axis.set_xlabel("X (cm)")
self.axis.set_ylabel("Y (cm)")
self.axis.set_zlabel("Z (µm)")
self.axis.set_title(title)
self.axis.mouse_init()
self.figure_canvas.draw()
QMessageBox.information(self, "QMessageBox.information()",
"Waviness calculated: if the result is satisfactory,\nclick \'Generate Waviness File\' to complete the operation ",
QMessageBox.Ok)
except Exception as exception:
QMessageBox.critical(self, "QMessageBox.critical()",
exception.args[0],
QMessageBox.Ok)
def generate_waviness_file(self):
if not self.zz is None and not self.yy is None and not self.xx is None:
if not self.waviness_file_name is None:
self.waviness_file_name = self.waviness_file_name.strip()
if self.waviness_file_name == "": raise Exception("Output File Name missing")
else:
raise Exception("Output File Name missing")
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
ST.write_shadow_surface(self.zz.T, self.xx, self.yy, outFile=self.waviness_file_name)
QMessageBox.information(self, "QMessageBox.information()",
"Waviness file " + self.waviness_file_name + " written on disk",
QMessageBox.Ok)
self.send("PreProcessor_Data", ShadowPreProcessorData(waviness_data_file=self.waviness_file_name))
def call_reset_settings(self):
if ConfirmDialog.confirmed(parent=self, message="Confirm Reset of the Fields?"):
try:
self.resetSettings()
self.reload_harmonics_table()
except:
pass
def check_fields(self):
self.number_of_points_x = ShadowGui.checkStrictlyPositiveNumber(self.number_of_points_x, "Number of Points X")
self.number_of_points_y = ShadowGui.checkStrictlyPositiveNumber(self.number_of_points_y, "Number of Points Y")
self.dimension_x = ShadowGui.checkStrictlyPositiveNumber(self.dimension_x, "Dimension X")
self.dimension_y = ShadowGui.checkStrictlyPositiveNumber(self.dimension_y, "Dimension Y")
self.estimated_slope_error = ShadowGui.checkPositiveNumber(self.estimated_slope_error, "Estimated slope error")
self.montecarlo_seed = ShadowGui.checkPositiveNumber(self.montecarlo_seed, "Monte Carlo initial seed")
self.harmonic_maximum_index = ShadowGui.checkPositiveNumber(self.harmonic_maximum_index,
"Harmonic Maximum Index")
if not self.waviness_file_name is None:
self.waviness_file_name = self.waviness_file_name.strip()
if self.waviness_file_name == "": raise Exception("Output File Name missing")
else:
raise Exception("Output File Name missing")
def to_float_array(self, string_array):
float_array = []
for index in range(len(string_array)):
float_array.append(float(string_array[index]))
return float_array
def to_str_array(self, float_array):
string_array = []
for index in range(len(float_array)):
string_array.append(str(float_array[index]))
return string_array
def writeStdOut(self, text):
cursor = self.shadow_output.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(text)
self.shadow_output.setTextCursor(cursor)
self.shadow_output.ensureCursorVisible()
class TableCatalogOTF(QObject):
runCatalog = pyqtSignal(str)
def __init__(self):
def initGui():
self.tableWidget.setWindowTitle("Catalog OTF")
self.tableWidget.setSortingEnabled(False)
msgtrans = QCoreApplication.translate("CatalogOTF", "Layer,Total")
headers = msgtrans.split(',')
self.tableWidget.setColumnCount(len(headers))
self.tableWidget.setHorizontalHeaderLabels(headers)
self.tableWidget.resizeColumnsToContents()
super(TableCatalogOTF, self).__init__()
self.tableWidget = QTableWidget()
initGui()
def _getRowLayerID(self, layerID):
for row in range(self.tableWidget.rowCount()):
if layerID == self.tableWidget.cellWidget(row, 0).objectName():
return row
return -1
def _changedText(self, layerID, name, column):
row = self._getRowLayerID(layerID)
if row != -1:
wgt = self.tableWidget.cellWidget(
row, column) if column == 0 else self.tableWidget.item(
row, column)
wgt.setText(name)
wgt.setToolTip(name)
self.tableWidget.resizeColumnsToContents()
@pyqtSlot()
def _onRunCatalog(self):
btn = self.sender()
icon = QIcon(joinPath(dirname(__file__), 'cancel_red.svg'))
btn.setIcon(icon)
layerID = btn.objectName()
self.runCatalog.emit(layerID)
@pyqtSlot()
def _onSelectionChanged(self):
layer = self.sender()
row = self._getRowLayerID(layer.id())
if row != -1:
wgt = self.tableWidget.cellWidget(row, 0)
nameIcon = 'check_green.svg' if layer.selectedFeatureCount(
) == 0 else 'check_yellow.svg'
icon = QIcon(joinPath(dirname(__file__), nameIcon))
wgt.setIcon(icon)
@pyqtSlot("QgsVectorLayer")
def insertRow(self, layer):
row = self.tableWidget.rowCount()
self.tableWidget.insertRow(row)
column = 0 # Layer
layerName = layer.name()
nameIcon = 'check_green.svg' if layer.selectedFeatureCount(
) == 0 else 'check_yellow.svg'
icon = QIcon(joinPath(dirname(__file__), nameIcon))
btn = QPushButton(icon, layerName, self.tableWidget)
btn.setObjectName(layer.id())
btn.setToolTip(layerName)
btn.clicked.connect(self._onRunCatalog)
layer.selectionChanged.connect(self._onSelectionChanged)
self.tableWidget.setCellWidget(row, column, btn)
column = 1 # Total
msgtrans = QCoreApplication.translate("CatalogOTF", "None")
item = QTableWidgetItem(msgtrans)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(row, column, item)
self.tableWidget.resizeColumnsToContents()
@pyqtSlot(str)
def removeRow(self, layerID):
row = self._getRowLayerID(layerID)
if row != -1:
self.tableWidget.removeRow(row)
@pyqtSlot(str, str)
def changedNameLayer(self, layerID, name):
self._changedText(layerID, name, 0)
@pyqtSlot(str, str)
def changedTotal(self, layerID, value):
self._changedText(layerID, value, 1)
@pyqtSlot(str, bool)
def changedIconRun(self, layerID, selected):
row = self._getRowLayerID(layerID)
if row != -1:
btn = self.tableWidget.cellWidget(row, 0)
nameIcon = 'check_green.svg' if not selected else 'check_yellow.svg'
icon = QIcon(joinPath(dirname(__file__), nameIcon))
btn.setIcon(icon)
btn.setEnabled(True)
@pyqtSlot(str)
def killed(self, layerID):
row = self._getRowLayerID(layerID)
if row != -1:
btn = self.tableWidget.cellWidget(row, 0)
btn.setEnabled(False)
def widget(self):
return self.tableWidget
class PatternsTable(QWidget):
def __init__(self):
QWidget.__init__(self)
self.grid = QGridLayout()
self.setLayout(self.grid)
self.patternArea()
self.patternTable()
def createPattern(self, name, x):
label = name.lower() + "Label"
type = name.lower() + "Type"
entry = name.lower() + "Entry"
setattr(self, label, QLabel(name))
setattr(self, entry, QLineEdit())
setattr(self, type, QComboBox())
labelobj = getattr(self, label)
typeobj = getattr(self, type)
entryobj = getattr(self, entry)
typeobj.addItem("Hexadecimal")
typeobj.addItem("String")
self.grid.addWidget(labelobj, x, 0)
self.grid.addWidget(entryobj, x, 1)
self.grid.addWidget(typeobj, x, 2)
def patternArea(self):
self.filetypeLabel = QLabel("File type")
self.filetype = QLineEdit()
self.alignedLabel = QLabel("block aligned")
self.aligned = QCheckBox()
self.windowLabel = QLabel("Window size")
self.window = QSpinBox()
self.window.setSuffix(" bytes")
self.window.setRange(0, 2500000)
self.window.setSingleStep(100)
self.addEntry = QPushButton("add")
self.connect(self.addEntry, SIGNAL("clicked()"), self.insertPattern)
self.grid.addWidget(self.filetypeLabel, 0, 0)
self.grid.addWidget(self.filetype, 0, 1, 1, 2)
self.createPattern("Header", 2)
self.createPattern("Footer", 3)
self.grid.addWidget(self.windowLabel, 4, 0)
self.grid.addWidget(self.window, 4, 1)
self.grid.addWidget(self.alignedLabel, 5, 0)
self.grid.addWidget(self.aligned, 5, 1)
self.grid.addWidget(self.addEntry, 6, 1)
def patternTable(self):
self.patterns = QTableWidget()
self.patterns.setShowGrid(False)
self.patterns.setColumnCount(5)
self.patterns.setHorizontalHeaderLabels(["Filetype", "Header", "Footer", "Window", "Block aligned"])
self.patterns.horizontalHeader().setStretchLastSection(True)
self.connect(self.patterns.verticalHeader(), SIGNAL("sectionClicked(int)"), self.patterns.removeRow)
self.grid.addWidget(self.patterns, 7, 0, 1, 3)
def warning(self, msg):
msgBox = QMessageBox(self)
msgBox.setText(msg)
msgBox.setIcon(QMessageBox.Warning)
msgBox.exec_()
def validate(self, **kwargs):
msg = ""
if len(kwargs["type"]) == 0:
msg = "Type must be defined"
else:
for i in kwargs["type"]:
if i not in string.letters:
msg = "Type's characters must be in the following set\n\n" + string.letters
break
rowCount = self.patterns.rowCount()
for row in range(0, rowCount):
if str(self.patterns.item(row, 0).text()) == kwargs["type"]:
msg = "Type <" + kwargs["type"] + " > already defined"
if msg != "":
self.warning(msg)
return False
if kwargs["headerType"] == "Hexadecimal" and not self.isHex(kwargs["header"]):
msg = "Header must be an even number of chars"
self.warning(msg)
return False
if len(kwargs["header"]) == 0:
msg = "Header must be provided"
self.warning(msg)
return False
if kwargs["footerType"] == "Hexadecimal" and not self.isHex(kwargs["header"]):
msg = "Footer must be an even number of chars"
self.warning(msg)
return False
if kwargs["window"] <= 0:
msg = "Window size must be greater than 0"
self.warning(msg)
return False
return True
def insertPattern(self):
filetype = str(self.filetype.text())
header = str(self.headerEntry.text())
headerType = str(self.headerType.currentText())
footer = str(self.footerEntry.text())
footerType = str(self.footerType.currentText())
window = self.window.text()
aligned = self.aligned.isChecked()
#Validate most of provided items
kwargs = {"type": filetype, "header": header, "headerType": headerType,
"footer": footer, "footerType": footerType, "window": int(window.replace(" bytes", ""))}
if not self.validate(**kwargs):
return
filetypeItem = QTableWidgetItem(filetype)
headerItem = QTableWidgetItem(header + " (" + headerType[0:3] + ")")
footerItem = QTableWidgetItem(footer + " (" + footerType[0:3] + ")")
windowItem = QTableWidgetItem(window)
alignedItem = QTableWidgetItem(str(aligned))
self.patterns.insertRow(self.patterns.rowCount())
vertHeader = QTableWidgetItem(QIcon(":closetab.png"), "")
row = self.patterns.rowCount() - 1
self.patterns.setVerticalHeaderItem(row, vertHeader)
self.patterns.setItem(row, 0, filetypeItem)
self.patterns.setItem(row, 1, headerItem)
self.patterns.setItem(row, 2, footerItem)
self.patterns.setItem(row, 3, windowItem)
self.patterns.setItem(row, 4, alignedItem)
self.patterns.resizeRowToContents(row)
def isHex(self, str):
HEXCHAR = "0123456789abcdefABCDEF"
hexStr = ""
even = False
for i in range(len(str)):
if str[i] in HEXCHAR:
if even == True:
even = False
else:
even = True
else:
return False
if even:
return False
return True
def toHex(self, str):
HEXCHAR = "0123456789abcdefABCDEF"
hexStr = ""
evenhex = ""
for i in range(len(str)):
if str[i] in HEXCHAR:
if len(evenhex) == 1:
hexStr += chr(int(evenhex+str[i], 16))
evenhex = ""
else:
evenhex = str[i]
else:
raise ValueError, "argument 'str' contains not valid characters"
if len(evenhex) != 0:
raise ValueError, "argument 'str' must be an even number of char"
return hexStr
def textToPattern(self, text):
idx = text.find("(")
pattern = ""
if idx != -1:
type = text[idx+1:idx+4]
pattern = text[0:idx-1]
if type == "Hex":
pattern = self.toHex(pattern)
return pattern
def selectedItems(self):
selected = {}
rowCount = self.patterns.rowCount()
for row in range(0, rowCount):
filetype = str(self.patterns.item(row, 0).text())
selected[filetype] = []
pattern = []
pattern.append(self.textToPattern(str(self.patterns.item(row, 1).text())))
pattern.append(self.textToPattern(str(self.patterns.item(row, 2).text())))
pattern.append(int(self.patterns.item(row, 3).text().replace(" bytes", "")))
selected[filetype].append([pattern])
if self.patterns.item(row, 4).text() == "True":
selected[filetype].append(True)
else:
selected[filetype].append(False)
return selected
class TemplateWindow(QMainWindow):
def __init__(self, params_pipe, number_pipe, templates_pipe, spikes_pipe,
probe_path=None, screen_resolution=None):
QMainWindow.__init__(self)
# Receive parameters.
params = params_pipe[0].recv()
self.probe = load_probe(probe_path)
self._nb_samples = params['nb_samples']
self._sampling_rate = params['sampling_rate']
self._display_list = []
self._params = {
'nb_samples': self._nb_samples,
'sampling_rate': self._sampling_rate,
'time': {
'min': 10.0, # ms
'max': 100.0, # ms
'init': 100.0, # ms
},
'voltage': {
'min': -200, # µV
'max': 20e+1, # µV
'init': 50.0, # µV
},
'templates': self._display_list
}
self._canvas_mea = MEACanvas(probe_path=probe_path, params=self._params)
self._canvas_template = TemplateCanvas(probe_path=probe_path, params=self._params)
self._canvas_rate = RateCanvas(probe_path=probe_path, params=self._params)
self._canvas_isi = ISICanvas(probe_path=probe_path, params=self._params)
self.cells = Cells({})
self._nb_buffer = 0
# TODO ISI
self.isi_bin_width, self.isi_x_max = 2, 25.0
canvas_template_widget = self._canvas_template.native
canvas_mea = self._canvas_mea.native
canvas_rate = self._canvas_rate.native
canvas_isi = self._canvas_isi.native
# Create controls widgets.
label_time = QLabel()
label_time.setText(u"time")
label_time_unit = QLabel()
label_time_unit.setText(u"ms")
self._dsp_time = QDoubleSpinBox()
self._dsp_time.setMinimum(self._params['time']['min'])
self._dsp_time.setMaximum(self._params['time']['max'])
self._dsp_time.setValue(self._params['time']['init'])
self._dsp_time.valueChanged.connect(self._on_time_changed)
label_voltage = QLabel()
label_voltage.setText(u"voltage")
label_voltage_unit = QLabel()
label_voltage_unit.setText(u"µV")
self._dsp_voltage = QDoubleSpinBox()
self._dsp_voltage.setMinimum(self._params['voltage']['min'])
self._dsp_voltage.setMaximum(self._params['voltage']['max'])
self._dsp_voltage.setValue(self._params['voltage']['init'])
self._dsp_voltage.valueChanged.connect(self._on_voltage_changed)
label_binsize = QLabel()
label_binsize.setText(u"Bin size")
label_binsize_unit = QLabel()
label_binsize_unit.setText(u"second")
self._dsp_binsize = QDoubleSpinBox()
self._dsp_binsize.setRange(0.1, 10)
self._dsp_binsize.setSingleStep(0.1)
self.bin_size = 1
self._dsp_binsize.setValue(self.bin_size)
self._dsp_binsize.valueChanged.connect(self._on_binsize_changed)
label_zoomrates = QLabel()
label_zoomrates.setText(u'Zoom rates')
self._zoom_rates = QDoubleSpinBox()
self._zoom_rates.setRange(1, 50)
self._zoom_rates.setSingleStep(0.1)
self._zoom_rates.setValue(1)
self._zoom_rates.valueChanged.connect(self._on_zoomrates_changed)
label_time_window = QLabel()
label_time_window.setText(u'Time window rates')
label_time_window_unit = QLabel()
label_time_window_unit.setText(u'second')
self._dsp_tw_rate = QDoubleSpinBox()
self._dsp_tw_rate.setRange(1, 50)
self._dsp_tw_rate.setSingleStep(self.bin_size)
self._dsp_tw_rate.setValue(50 * self.bin_size)
self._dsp_tw_rate.valueChanged.connect(self._on_time_window_changed)
label_tw_from_start = QLabel()
label_tw_from_start.setText('Time scale from start')
self._tw_from_start = QCheckBox()
self._tw_from_start.setChecked(True)
self._selection_templates = QTableWidget()
self._selection_templates.setSelectionMode(
QAbstractItemView.ExtendedSelection
)
self._selection_templates.setColumnCount(3)
self._selection_templates.setVerticalHeaderLabels(['Nb template', 'Channel', 'Amplitude'])
self._selection_templates.insertRow(0)
self._selection_templates.setItem(0, 0, QTableWidgetItem('Nb template'))
self._selection_templates.setItem(0, 1, QTableWidgetItem('Channel'))
self._selection_templates.setItem(0, 2, QTableWidgetItem('Amplitude'))
# self._selection_channels.setGeometry(QtCore.QRect(10, 10, 211, 291))
# for i in range(self.nb_templates):
# numRows = self.tableWidget.rowCount()
# self.tableWidget.insertRow(numRows)
# item = QTableWidgetItem("Template %i" % i)
# self._selection_templates.addItem(item)
# self._selection_templates.item(i).setSelected(False)
spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
# Create controls grid.
grid = QGridLayout()
# # Add time row.
grid.addWidget(label_time, 0, 0)
grid.addWidget(self._dsp_time, 0, 1)
grid.addWidget(label_time_unit, 0, 2)
# # Add voltage row.
grid.addWidget(label_voltage, 1, 0)
grid.addWidget(self._dsp_voltage, 1, 1)
grid.addWidget(label_voltage_unit, 1, 2)
# # Add binsize row.
grid.addWidget(label_binsize, 2, 0)
grid.addWidget(self._dsp_binsize, 2, 1)
grid.addWidget(label_binsize_unit, 2, 2)
# # Add zoom rate
grid.addWidget(label_zoomrates, 3, 0)
grid.addWidget(self._zoom_rates, 3, 1)
# Add a double checkbox for time window
grid.addWidget(label_time_window, 4, 0)
grid.addWidget(self._dsp_tw_rate, 4, 1)
grid.addWidget(label_time_window_unit, 4, 2)
## Add checkbox to display the rates from start
grid.addWidget(label_tw_from_start, 5, 0)
grid.addWidget(self._tw_from_start, 5, 1)
# # Add spacer.
grid.addItem(spacer)
# # Create info group.
controls_group = QGroupBox()
controls_group.setLayout(grid)
# Create info grid.
templates_grid = QGridLayout()
# # Add Channel selection
# grid.addWidget(label_selection, 3, 0)
templates_grid.addWidget(self._selection_templates, 0, 1)
def add_template():
items = self._selection_templates.selectedItems()
self._display_list = []
for i in range(len(items)):
self._display_list.append(i)
self._on_templates_changed()
# self._selection_templates.itemClicked.connect(add_template)
# Template selection signals
self._selection_templates.itemSelectionChanged.connect(lambda: self.selected_templates(
self.nb_templates))
# Checkbox to display all the rates
self._tw_from_start.stateChanged.connect(self.time_window_rate_full)
# self._selection_templates.itemPressed(0, 1).connect(self.sort_template())
# # Add spacer.
templates_grid.addItem(spacer)
# Create controls group.
templates_group = QGroupBox()
templates_group.setLayout(templates_grid)
# # Create controls dock.
templates_dock = QDockWidget()
templates_dock.setWidget(templates_group)
templates_dock.setWindowTitle("Channels selection")
# # Create controls dock.
control_dock = QDockWidget()
control_dock.setWidget(controls_group)
control_dock.setWindowTitle("Controls")
# Create info widgets.
label_time = QLabel()
label_time.setText(u"time")
self._label_time_value = QLineEdit()
self._label_time_value.setText(u"0")
self._label_time_value.setReadOnly(True)
self._label_time_value.setAlignment(Qt.AlignRight)
label_time_unit = QLabel()
label_time_unit.setText(u"s")
info_buffer_label = QLabel()
info_buffer_label.setText(u"buffer")
self._info_buffer_value_label = QLineEdit()
self._info_buffer_value_label.setText(u"0")
self._info_buffer_value_label.setReadOnly(True)
self._info_buffer_value_label.setAlignment(Qt.AlignRight)
info_buffer_unit_label = QLabel()
info_buffer_unit_label.setText(u"")
info_probe_label = QLabel()
info_probe_label.setText(u"probe")
info_probe_value_label = QLineEdit()
info_probe_value_label.setText(u"{}".format(probe_path))
info_probe_value_label.setReadOnly(True)
# TODO place the following info in another grid?
info_probe_unit_label = QLabel()
info_probe_unit_label.setText(u"")
info_spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
# Create info grid.
info_grid = QGridLayout()
# # Time row.
info_grid.addWidget(label_time, 0, 0)
info_grid.addWidget(self._label_time_value, 0, 1)
info_grid.addWidget(label_time_unit, 0, 2)
# # Buffer row.
info_grid.addWidget(info_buffer_label, 1, 0)
info_grid.addWidget(self._info_buffer_value_label, 1, 1)
info_grid.addWidget(info_buffer_unit_label, 1, 2)
# # Probe row.
info_grid.addWidget(info_probe_label, 2, 0)
info_grid.addWidget(info_probe_value_label, 2, 1)
info_grid.addWidget(info_probe_unit_label, 2, 2)
# # Spacer.
info_grid.addItem(info_spacer)
# Create info group.
info_group = QGroupBox()
info_group.setLayout(info_grid)
# Create info dock.
info_dock = QDockWidget()
info_dock.setWidget(info_group)
info_dock.setWindowTitle("Info")
# Create thread.
thread = Thread(number_pipe, templates_pipe, spikes_pipe)
thread.number_signal.connect(self._number_callback)
thread.reception_signal.connect(self._reception_callback)
thread.start()
# Add dockable windows.
self.addDockWidget(Qt.LeftDockWidgetArea, control_dock)
self.addDockWidget(Qt.LeftDockWidgetArea, info_dock)
self.addDockWidget(Qt.LeftDockWidgetArea, templates_dock)
# Add Grid Layout for canvas
canvas_grid = QGridLayout()
group_canv_temp = QDockWidget()
group_canv_temp.setWidget(canvas_template_widget)
group_canv_mea = QDockWidget()
group_canv_mea.setWidget(canvas_mea)
group_canv_rate = QDockWidget()
group_canv_rate.setWidget(canvas_rate)
group_canv_isi = QDockWidget()
group_canv_isi.setWidget(canvas_isi)
canvas_grid.addWidget(group_canv_temp, 0, 0)
canvas_grid.addWidget(group_canv_mea, 0, 1)
canvas_grid.addWidget(group_canv_rate, 1, 1)
canvas_grid.addWidget(group_canv_isi, 1, 0)
canvas_group = QGroupBox()
canvas_group.setLayout(canvas_grid)
# Set central widget.
self.setCentralWidget(canvas_group)
# Set window size.
if screen_resolution is not None:
screen_width = screen_resolution.width()
screen_height = screen_resolution.height()
self.resize(screen_width, screen_height)
# Set window title.
self.setWindowTitle("SpyKING Circus ORT - Read 'n' Qt display")
print(" ") # TODO remove?
@property
def nb_templates(self):
return len(self.cells)
def _number_callback(self, number):
self._nb_buffer = float(number)
text = u"{}".format(number)
self._info_buffer_value_label.setText(text)
text = u"{:8.3f}".format(self._nb_buffer * float(self._nb_samples) / self._sampling_rate)
self._label_time_value.setText(text)
return
def _reception_callback(self, templates, spikes):
bar = None
if templates is not None:
bar = []
for i in range(len(templates)):
mask = spikes['templates'] == i
template = load_template_from_dict(templates[i], self.probe)
new_cell = Cell(template, Train([]), Amplitude([], []))
self.cells.append(new_cell)
self._selection_templates.insertRow(self.nb_templates)
bar += [template.center_of_mass(self.probe)]
channel = template.channel
amplitude = template.peak_amplitude()
# self._selection_templates.setItem(self.nb_templates, 0, QTableWidgetItem("Template %d" %self.nb_templates))
# self._selection_templates.setItem(self.nb_templates, 1, QTableWidgetItem(str(bar)))
self._selection_templates.setItem(self.nb_templates, 0, QTableWidgetItem(str(self.nb_templates)))
self._selection_templates.setItem(self.nb_templates, 1, QTableWidgetItem(str(channel)))
self._selection_templates.setItem(self.nb_templates, 2, QTableWidgetItem(str(amplitude)))
# item = QListWidgetItem("Template %i" % self.nb_templates)
# self._selection_templates.addItem(item)
# self._selection_templates.item(i).setSelected(False)
# self.nb_templates += 1
# print(bar.shape, bar)
if spikes is not None:
self.cells.add_spikes(spikes['spike_times'], spikes['amplitudes'], spikes['templates'])
self.cells.set_t_max(self._nb_samples * self._nb_buffer / self._sampling_rate)
to_display = self.cells.rate(self.bin_size)
self._canvas_template.on_reception(templates, self.nb_templates)
self._canvas_mea.on_reception_bary(bar, self.nb_templates)
# TODO Cells rate
self._canvas_rate.on_reception_rates(self.cells.rate(self.bin_size))
# TODO : ISI If we want to display the ISI also
# isi = self.cells.interspike_interval_histogram(self.isi_bin_width, self.isi_x_max=25.0)
isi = self.cells.interspike_interval_histogram(self.isi_bin_width, self.isi_x_max)
self._canvas_isi.on_reception_isi(isi)
return
def _on_time_changed(self):
time = self._dsp_time.value()
self._canvas_template.set_time(time)
self._dsp_tw_rate.setRange(1, int(time))
return
def _on_binsize_changed(self):
time = self._dsp_binsize.value()
self.bin_size = time
self._dsp_tw_rate.setSingleStep(self.bin_size)
return
def _on_zoomrates_changed(self):
zoom_value = self._zoom_rates.value()
self._canvas_rate.zoom_rates(zoom_value)
return
def _on_voltage_changed(self):
voltage = self._dsp_voltage.value()
self._canvas_template.set_voltage(voltage)
return
def _on_peaks_display(self):
value = self._display_peaks.isChecked()
self._canvas_template.show_peaks(value)
return
def _on_templates_changed(self):
self._canvas_template.set_templates(self._display_list)
return
def selected_templates(self, max_templates):
list_templates = []
list_channels = []
for i in range(max_templates + 1):
if i != 0 and \
self._selection_templates.item(i, 0).isSelected() and \
self._selection_templates.item(i, 1).isSelected() and \
self._selection_templates.item(i, 2).isSelected():
list_templates.append(i - 1)
list_channels.append(int(self._selection_templates.item(i, 1).text()))
self._canvas_template.selected_templates(list_templates)
self._canvas_mea.selected_channels(list_channels)
self._canvas_mea.selected_templates(list_templates)
self._canvas_rate.selected_cells(list_templates)
self._canvas_isi.selected_cells(list_templates)
return
def time_window_rate_full(self):
value = self._tw_from_start.isChecked()
self._canvas_rate.time_window_full(value)
return
def _on_time_window_changed(self):
tw_value = self._dsp_tw_rate.value()
self._canvas_rate.time_window_value(tw_value, self.bin_size)
return
class CorrectorViewer(QtGui.QWidget):
"""
List all corrector and select part to lower table
"""
def __init__(self, cors, field, parent=None, nmax=4):
super(CorrectorViewer, self).__init__(parent)
self._nmax = nmax
self._field = field
self._cors = cors
self._corlst1 = QtGui.QTreeWidget()
self._header = dict([("Element", 0), ("Family", 1), ("s [m]", 2),
("Alpha X", 3), ("Alpha Y", 4), ("Beta X", 5),
("Beta Y", 6), ("Phi X", 7), ("Phi Y", 8),
("Eta X", 9)])
self._twiss = np.zeros((len(self._cors), 8), 'd')
self._tunes = getTunes(source="database")
self._corlst1.setColumnCount(len(self._header))
self._corlst1.setHeaderLabels(
sorted(self._header, key=self._header.get))
self._corlst1.header().setStretchLastSection(False)
prevcell = None
for i,c in enumerate(self._cors):
if c.cell and (prevcell is None or c.cell != prevcell.text(0)):
# a new parent
prevcell = QtGui.QTreeWidgetItem()
prevcell.setText(0, c.cell)
self._corlst1.addTopLevelItem(prevcell)
it = QtGui.QTreeWidgetItem()
it.setData(0, Qt.UserRole, i)
it.setText(self._header["Element"], c.name)
it.setText(self._header["Family"], c.family)
it.setText(self._header["s [m]"], "%.3f" % c.sb)
try:
tw = getTwiss(c.name,
["s", "alphax", "alphay", "betax", "betay",
"phix", "phiy", "etax"])
self._twiss[i,:] = tw[0,:]
it.setText(self._header["Alpha X"], "%.4f" % self._twiss[i,1])
it.setText(self._header["Alpha Y"], "%.4f" % self._twiss[i,2])
it.setText(self._header["Beta X"], "%.4f" % self._twiss[i,3])
it.setText(self._header["Beta Y"], "%.4f" % self._twiss[i,4])
it.setText(self._header["Phi X"], "%.4f" % self._twiss[i,5])
it.setText(self._header["Phi Y"], "%.4f" % self._twiss[i,6])
it.setText(self._header["Eta X"], "%.4f" % self._twiss[i,7])
except:
it.setDisabled(True)
pass
if c.cell:
prevcell.addChild(it)
else:
self._corlst1.addTopLevelItem(it)
prevcell = it
for j in range(2, len(self._header)):
it.setTextAlignment(j, Qt.AlignRight)
self._corlst1.expandAll()
for i in range(len(self._header)):
self._corlst1.resizeColumnToContents(i)
#self._corlst1.setColumnWidth(0, 150)
#self.elemlst.setSelectionMode(QAbstractItemView.MultiSelection)
columns = ['Corrector', 's', 'Alpha', 'Beta',
'Phi', "dPhi", "Initial Bump", "Cur. Sp", "dBump",
"Final Rb"]
self.table4 = QTableWidget(0, len(columns))
#self.table4.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
hdview = QHeaderView(Qt.Horizontal)
self.table4.setHorizontalHeaderLabels(columns)
#for i in range(4):
# for j in range(len(columns)):
# it = QTableWidgetItem()
# if j > 0: it.setTextAlignment(
# Qt.AlignRight | Qt.AlignVCenter)
# if columns[j] != "dKick":
# it.setFlags(it.flags() & (~Qt.ItemIsEditable))
# self.table4.setItem(i, j, it)
#self.table4.resizeColumnsToContents()
#self.table4.horizontalHeader().setStretchLastSection(True)
#hrow = self.table4.rowHeight(0)
#htbl = (hrow * 4) + self.table4.horizontalHeader().height() +\
# 2*self.table4.frameWidth()
#self.table4.setMinimumHeight(htbl + 10)
#self.table4.setMaximumHeight(htbl + 15)
#self.table4.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
#print "Size:", htbl + 10
self.table4.resize(self.table4.width(), 150)
splitter = QtGui.QSplitter(Qt.Vertical)
splitter.addWidget(self._corlst1)
splitter.addWidget(self.table4)
vbox1 = QtGui.QVBoxLayout()
vbox1.addWidget(splitter)
self.setLayout(vbox1)
self.connect(self._corlst1, SIGNAL("doubleClicked(QModelIndex)"),
self.addCorrector)
#self.connect(self.src, SIGNAL("returnPressed()"),
# self._calc_source)
#self.connect(self.table4, SIGNAL("cellChanged(int, int)"),
# self.updateTable)
#self.connect(self.table4, SIGNAL("doubleClicked(QModelIndex)"),
# self.delCorrector)
self._x0 = fget(self._cors, "x", handle="setpoint", unitsys=None)
self._y0 = fget(self._cors, "y", handle="setpoint", unitsys=None)
def addCorrector(self, idx):
if not self._corlst1.selectedItems(): return
#print self._corlst1.itemFromIndex(idx).text(0)
nrow = self.table4.rowCount()
if nrow >= self._nmax:
QtGui.QMessageBox.critical(
self, "Local Orbit Bump",
"ERROR: We need only {0} correctors.".format(self._nmax),
QtGui.QMessageBox.Ok)
#self.progress.setValue(0)
return
self.table4.setRowCount(nrow+1)
it0 = self._corlst1.selectedItems()[-1]
icor, ok = it0.data(0, Qt.UserRole).toInt()
if icor < 0: return
newc = self._cors[icor]
for j in range(self.table4.columnCount()):
it = QTableWidgetItem()
if j > 0: it.setTextAlignment(
Qt.AlignRight | Qt.AlignVCenter)
header = self.table4.horizontalHeaderItem(j)
if header.text() != "dBump":
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
else:
it.setData(Qt.DisplayRole, "0")
it.setData(Qt.UserRole, 0.0)
self.table4.setItem(nrow, j, it)
self.table4.item(nrow,0).setData(Qt.UserRole, icor)
for j,h in [(0, "Element"), (1, "s [m]")]:
self.table4.item(nrow,j).setData(Qt.DisplayRole,
it0.text(self._header[h]))
for j in range(self._corlst1.columnCount()):
it0.setForeground(j, Qt.red)
it0.setDisabled(True)
self.emit(SIGNAL("correctorAdded(PyQt_PyObject)"), newc)
# use initial values
self.updateTwiss()
self.updateCorReadings()
self.table4.resizeColumnsToContents()
if self.table4.rowCount() == self._nmax:
#print "All correctors are ready"
self.emit(SIGNAL("correctorsComplete()"))
def updateTwiss(self):
if self._field == "x":
jl = [self._header[h] for h in ["Alpha X", "Beta X", "Phi X"]]
nu = self._tunes[0]
elif self._field == "y":
jl = [self._header[h] for h in ["Alpha Y", "Beta Y", "Phi Y"]]
nu = self._tunes[1]
else:
raise RuntimeError("unknown cor field {0}".format(self._field))
#print "index:", jl
# if rows provided use it, otherwise use all
for i in range(self.table4.rowCount()):
elemname = self.table4.item(i,0).data(Qt.DisplayRole).toString()
it0 = self._corlst1.findItems(
elemname, Qt.MatchExactly | Qt.MatchRecursive)[0]
self.table4.item(i,2).setText(it0.text(jl[0]))
self.table4.item(i,3).setText(it0.text(jl[1]))
self.table4.item(i,4).setText(it0.text(jl[2]))
self.table4.item(i,4).setData(Qt.UserRole, float(it0.text(jl[2])))
if i == 0:
self.table4.item(i,5).setText("0.0")
self.table4.item(i,5).setData(Qt.UserRole, 0.0)
else:
dph, ok = self.table4.item(i-1,5).data(Qt.UserRole).toFloat()
ph0, ok = self.table4.item(i-1,4).data(Qt.UserRole).toFloat()
ph1, ok = self.table4.item(i,4).data(Qt.UserRole).toFloat()
dph = dph + ph1 - ph0
if ph1 < ph0:
dph = dph + 2.0*np.pi*nu
#print "Updating twiss:", i, dph
self.table4.item(i,5).setData(Qt.UserRole, dph)
self.table4.item(i,5).setText("%.5g" % dph)
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
#c = self._cors[icor]
#kick = self._cors[icor].get(self._field, unitsys=None)
#self.table4.item(i,6).setData(Qt.UserRole, kick)
#self.table4.item(i,6).setText("%.5g" % kick)
#self.updateKickReadings(col=0)
def clear(self):
for i in range(self.table4.rowCount()):
elemname = self.table4.item(i,0).data(Qt.DisplayRole).toString()
it0 = self._corlst1.findItems(
elemname, Qt.MatchExactly | Qt.MatchRecursive)[0]
it0.setDisabled(False)
for j in range(self._corlst1.columnCount()):
it0.setForeground(j, Qt.black)
self.table4.setRowCount(0)
def updateCorReadings(self):
for i in range(self.table4.rowCount()):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
cor = self._cors[icor]
if self._field == "x":
self.table4.item(i,6).setData(Qt.UserRole, self._x0[icor])
self.table4.item(i,6).setText("%.5g" % self._x0[icor])
elif self._field == "y":
self.table4.item(i,6).setData(Qt.UserRole, self._y0[icor])
self.table4.item(i,6).setText("%.5g" % self._y0[icor])
kicksp = cor.get(self._field, handle="setpoint", unitsys=None)
self.table4.item(i,7).setData(Qt.UserRole, float(kicksp))
self.table4.item(i,7).setText("%.5g" % kicksp)
kickrb = cor.get(self._field, handle="readback", unitsys=None)
self.table4.item(i,9).setData(Qt.UserRole, float(kickrb))
self.table4.item(i,9).setText("%.5g" % kickrb)
def updateDbump(self, dkick):
nrow = min(self.table4.rowCount(), len(dkick))
for i in range(nrow):
# dbump column is 8
it = self.table4.item(i, 8)
if dkick[i] is None:
it.setData(Qt.DisplayRole, "")
it.setData(Qt.UserRole, 0.0)
else:
it.setData(Qt.UserRole, float(dkick[i]))
it.setData(Qt.DisplayRole, "{0}".format(dkick[i]))
self.updateCorReadings()
self.table4.resizeColumnsToContents()
#print "(0,7)", self.table4.item(0, 7).data(Qt.UserRole).toFloat()
#print "(0,7)", self.table4.item(0, 7).data(Qt.DisplayRole).toFloat()
def applyKick(self):
nrow = self.table4.rowCount()
for i in range(nrow):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
cor = self._cors[icor]
# Current SP: 7, dBump 8
k0, ok = self.table4.item(i, 7).data(Qt.UserRole).toFloat()
dk, ok = self.table4.item(i, 8).data(Qt.UserRole).toFloat()
#print "Setting {0} {1}+{2} [A]".format(cor.name, k0, dk)
cor.put(self._field, k0+dk, unitsys=None)
# update the final readings
self.updateCorReadings()
def getTwiss(self):
tw = {"s": [], "Alpha": [], "Beta": [],
"Phi": [], "dPhi": []}
nrow = self.table4.rowCount()
for j in range(self.table4.columnCount()):
header = self.table4.horizontalHeaderItem(j)
if header.text() not in tw.keys():
continue
k = str(header.text())
for i in range(nrow):
it = self.table4.item(i, j)
v0, ok0 = it.data(Qt.UserRole).toFloat()
v1, ok1 = it.data(Qt.DisplayRole).toFloat()
if ok0:
tw[k].append(v0)
elif ok1:
tw[k].append(v1)
else:
tw[k].append(np.nan)
return tw
def selectedCorrectors(self):
ret = []
for i in range(self.table4.rowCount()):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
ret.append(self._cors[icor])
return ret
def resetCorrectors(self):
for i in range(self.table4.rowCount()):
icor, ok = self.table4.item(i,0).data(Qt.UserRole).toInt()
cor = self._cors[icor]
if self._field == "x":
kick = self._x0[icor]
elif self._field == "y":
kick = self._y0[icor]
cor.put(self._field, kick, unitsys=None)
class ActionEditorDialog(QWidget):
# Redefine the tr() function for this class.
def tr(self, text):
return qApp.translate("ActionEditorDialog", text)
def __init__(self, actions, parent=None):
super(ActionEditorDialog, self).__init__(parent)
self.actions = actions
help = QLabel(translate("Shortcut Settings", '<b>Double click a cell in the Shortcut Column' \
' to <br />modify the key sequence.</b>'))
self.actionTable = QTableWidget(self)
self.actionTable.setSelectionBehavior(QTableWidget.SelectRows)
self.actionTable.setEditTriggers(QTableWidget.DoubleClicked)
self.actionTable.setColumnCount(2)
self.actionTable.setHorizontalHeaderLabels(
[translate("Shortcut Settings", "Description"),
translate("Shortcut Settings", "Shortcut")]
)
self.actionTable.horizontalHeader().setStretchLastSection(True)
self.actionTable.verticalHeader().hide()
self.actionTable.setItemDelegate(ActionEditorDelegate(self))
self.connect(self.actionTable, SIGNAL("cellChanged(int, int)"),
self.validateAction)
row = 0
for action in self.actions:
if action.text().isEmpty():
continue
self.actionTable.insertRow(self.actionTable.rowCount())
item = QTableWidgetItem()
item.setText(action.text())
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.actionTable.setItem(row, 0, item)
item = QTableWidgetItem()
item.setText(action.shortcut().toString())
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsSelectable)
item.oldShortcutText = item.text()
self.actionTable.setItem(row, 1, item)
row += 1
self.actionTable.resizeColumnsToContents()
mainLayout = QVBoxLayout()
mainLayout.addWidget(help)
mainLayout.setMargin(8)
mainLayout.setSpacing(8)
mainLayout.addWidget(self.actionTable)
self.setLayout(mainLayout)
self._model = self.actionTable.model()
self._model.edited = False
self.actionTable.model().edited = False
self.setWindowTitle(translate("Shortcut Settings", "Edit Shortcuts"))
def applySettings(self, control=None):
if not self._model.edited:
return
row = 0
for action in self.actions:
if not action.text().isEmpty():
action.setText(self.actionTable.item(row, 0).text())
action.setShortcut(QKeySequence(self.actionTable.item(row, 1).text()))
row += 1
self.saveSettings(self.actions)
self._model.edited = False
def _loadSettings(self, actions):
cparser = PuddleConfig(os.path.join(CONFIGDIR, 'user_shortcuts'))
for action in actions:
shortcut = cparser.get('shortcuts', unicode(action.text()), '')
if shortcut:
action.setShortcut(QKeySequence(shortcut))
_loadSettings = classmethod(_loadSettings)
def saveSettings(self, actions):
cparser = PuddleConfig(os.path.join(CONFIGDIR, 'user_shortcuts'))
for action in actions:
shortcut = unicode(action.shortcut().toString())
cparser.set('shortcuts', unicode(action.text()), shortcut)
saveSettings = classmethod(saveSettings)
def validateAction(self, row, column):
if column != 1:
return
item = self.actionTable.item(row, column)
shortcutText = QKeySequence(item.text()).toString()
thisRow = self.actionTable.row(item)
if not shortcutText.isEmpty():
for row in range(self.actionTable.rowCount()):
if row == thisRow:
continue
other = self.actionTable.item(row, 1)
if other.text() == shortcutText:
other.setText(item.oldShortcutText)
break
item.setText(shortcutText)
item.oldShortcutText = shortcutText
self.actionTable.resizeColumnToContents(1)
class PvTunerDlg(QDialog):
COL = 6
COL_ELEMENT = 0
COL_FIELD = 1
COL_PV = 2
COL_STEPSIZE = 3
COL_READBACK = 4
COL_SETPOINT = 5
FMT_READBACK = "%.4e"
def __init__(self, parent=None):
super(PvTunerDlg, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
#self.inputBox = QLineEdit("PL2G2C01A.x")
#self.inputBox = QLineEdit("CXH2G6C01B.x")
self.inputBox = QLineEdit("PL2G2C01A")
addPvBtn = QPushButton("add")
self.table = QTableWidget(0, PvTunerDlg.COL)
self.table.setHorizontalHeaderLabels(["Element", "Field", "PV",
"Stepsize", "Readback", "setpoint"])
#self.table.horizontalHeader().setStretchLastSection(True)
#self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
box = QGridLayout()
box.addWidget(self.inputBox, 0, 0)
box.addWidget(addPvBtn, 0, 1)
box.addWidget(self.table, 1, 0, 1, 2)
box.addWidget(buttonBox, 2, 0)
self.setLayout(box)
self.pvs_rb = []
self.pvs_rb_val_flat = []
self.pvs_sp = []
self.pvmoni = []
self.spinbox = []
self.connect(addPvBtn, SIGNAL("clicked()"), self.addPv)
self.connect(buttonBox, SIGNAL("accepted()"), self.accept)
#self.connect(self.table, SIGNAL("cellChanged"), self.updatePv)
self.connect(buttonBox.button(QDialogButtonBox.Ok),
SIGNAL("clicked()"), self.close)
self.connect(self.table, SIGNAL("cellClicked(int, int)"),
self._cell_clicked)
def _cell_clicked(self, row, column):
#print row, column
if column in [self.COL_PV, self.COL_STEPSIZE]:
item = self.table.item(row, column)
if not item: return
item.setFlags(item.flags() | Qt.ItemIsEditable)
def _appendRecord(self, name):
vec = name.split('.')
if len(vec) > 2:
QMessageBox.critical(None, "ERROR", "format is wrong")
return
if len(vec) == 1:
elem, field = vec[0], 'value'
elif len(vec) == 2:
elem, field = vec
elemobj = hla.getElements(elem)
if elemobj:
# pvsrb is a list
pvsrb = elemobj.pv(field=field, handle='readback')
self.pvs_rb.append(pvsrb)
pvssp = elemobj.pv(field=field, handle='setpoint')
self.pvs_sp.append(pvssp)
else:
QMessageBox.critical(None, "ERROR", "element %s not found" % elem)
return
# expand one row
m, n = self.table.rowCount(), self.table.columnCount()
self.table.insertRow(m)
# add cells
item = QTableWidgetItem(elem)
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_ELEMENT, item)
item = QTableWidgetItem(field)
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_FIELD, item)
item = QTableWidgetItem(', '.join(pvsrb))
#item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
self.table.setItem(m, self.COL_PV, item)
readval = ['%.4e' % v for v in caget(pvsrb)]
item = QTableWidgetItem(', '.join(readval))
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_READBACK, item)
# set the stepsize of PV
stepsize = 0.00001
if pvssp:
item = QTableWidgetItem('%f' % stepsize)
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_STEPSIZE, item)
self.spinbox.append(QDoubleSpinBox(self.table))
self.spinbox[-1].setRange(-100, 100)
#self.spinbox[-1].setValue(float(10.0))
self.spinbox[-1].setSingleStep(stepsize)
self.spinbox[-1].setDecimals(10)
self.spinbox[-1].valueChanged.connect(self._writePv)
self.table.setCellWidget(m, self.COL_SETPOINT, self.spinbox[-1])
sp = float(caget(pvssp)[0])
#print "setpoint:", pvssp, sp, type(sp)
self.spinbox[-1].setValue(-1e-5)
#print "connected", self.spinbox[-1].value()
else:
item = self.table.item(m, self.COL_STEPSIZE)
if item: item.setFlags(item.flags() & (~Qt.ItemIsEditable))
item = self.table.item(m, self.COL_SETPOINT)
if item: item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.spinbox.append(None)
self.table.resizeColumnsToContents()
def addPv(self):
self._appendRecord(str(self.inputBox.text()))
self._updateMonitors()
def minimalSizeHint(self):
return QSize(800, 600)
def _writePv(self, v):
"""
"""
c = QObject.sender(self)
i = self.spinbox.index(c)
#print i, c.text(), "changed"
#print self.pvs_sp[i], v
caput(self.pvs_sp[i], v)
def _updateMonitors(self):
"""
prepare the PV list for camonitor
"""
#print "Updating monitors"
pvs = []
self.pvs_rb_val = []
for i in range(self.table.rowCount()):
for j in range(len(self.pvs_rb[i])):
self.pvs_rb_val.append([i, 0.0])
pvs.extend(self.pvs_rb[i])
for p in self.pvmoni: p.close()
self.pvmoni = camonitor(pvs, self._updatePvValues)
#print self.pvmoni
#print pvs
#print self.pvs_rb_val
def _updatePvValues(self, val, idx):
#print idx, val
s = []
for i, v in enumerate(self.pvs_rb_val):
if v[0] == self.pvs_rb_val[idx][0]:
s.append(self.FMT_READBACK % val)
#print s
item = self.table.item(self.pvs_rb_val[idx][0], self.COL_READBACK)
item.setText(','.join(s))
def closePvMonitors(self):
#print "Closing PV Monitors"
for p in self.pvmoni: p.close()
pass
def closeEvent(self, event):
self.closePvMonitors()
event.accept()
def close(self):
self.closePvMonitors()
return True
class RLibraryBrowser(QDialog):
def __init__(self, parent=None, paths=None):
QDialog.__init__(self, parent)
QShortcut(QKeySequence("Escape"), self, self.reject)
self.setWindowTitle("manageR - Library Browser")
self.resize(500, 500)
port = robjects.r('tools:::httpdPort')[0]
if not port > 0:
robjects.r('tools::startDynamicHelp()')
port = robjects.r('tools:::httpdPort')[0]
robjects.r("""make.packages.html()""")
host = "localhost"
home = "/doc/html/packages.html"
#splitter = QSplitter(self)
#splitter.setOrientation(Qt.Vertical)
#splitter.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
labels = QStringList(["Loaded", "Package",
"Title", "Path"])
self.parent = parent
self.home = home
self.packageTable = QTableWidget(0, 4, self)
self.htmlViewer = HtmlBrowser(self, host, port, home, paths)
#splitter.addWidget(self.packageTable)
#splitter.addWidget(self.htmlViewer)
vbox = QVBoxLayout(self)
#hbox.addWidget(splitter)
vbox.addWidget(self.packageTable)
vbox.addWidget(self.htmlViewer)
self.packageTable.setHorizontalHeaderLabels(labels)
self.packageTable.setShowGrid(True)
self.packageTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.packageTable.setSelectionMode(QAbstractItemView.SingleSelection)
self.packageTable.setAlternatingRowColors(True)
self.updatePackages()
self.connect(self.packageTable,
SIGNAL("itemChanged(QTableWidgetItem*)"), self.loadPackage)
self.connect(self.packageTable,
SIGNAL("itemDoubleClicked(QTableWidgetItem*)"), self.showPackage)
def setSource(self, source):
self.htmlViewer.setSource(source)
def showPackage(self, item):
row = item.row()
tmp = self.packageTable.item(row, 1)
package = tmp.text()
home = QUrl(self.home)
curr = QUrl("../../library/%s/html/00Index.html" % package)
self.htmlViewer.setSource(home.resolved(curr))
def loadPackage(self, item):
row = item.row()
tmp = self.packageTable.item(row, 1)
package = tmp.text()
if item.checkState() == Qt.Checked:
command = "library(%s)" % package
else:
command = "detach('package:%s')" % package
robjects.r(command)
#self.emit(SIGNAL(...(command)
def updatePackages(self):
library_ = robjects.r.get('library', mode='function')
packages_ = robjects.r.get('.packages', mode='function')
loaded = list(packages_())
packages = list(library_()[1])
length = len(packages)
self.packageTable.clearContents()
#self.table.setRowCount(length/3)
packageList = []
for i in range(length/3):
package = unicode(packages[i])
if not package in packageList:
packageList.append(package)
self.packageTable.setRowCount(len(packageList))
item = QTableWidgetItem("Loaded")
item.setFlags(
Qt.ItemIsUserCheckable|Qt.ItemIsEnabled|Qt.ItemIsSelectable)
if package in loaded:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.packageTable.setItem(i, 0, item)
item = QTableWidgetItem(unicode(packages[i]))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.packageTable.setItem(i, 1, item)
item = QTableWidgetItem(unicode(packages[i+(2*(length/3))]))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.packageTable.setItem(i, 2, item)
item = QTableWidgetItem(unicode(packages[i+(length/3)]))
item.setFlags(Qt.ItemIsEnabled|Qt.ItemIsSelectable)
self.packageTable.setItem(i, 3, item)
self.packageTable.resizeColumnsToContents()
class OWdabam_height_profile(OWWidget):
name = "DABAM Height Profile"
id = "dabam_height_profile"
description = "Calculation of mirror surface error profile"
icon = "icons/dabam.png"
author = "Luca Rebuffi"
maintainer_email = "[email protected]; [email protected]"
priority = 6
category = ""
keywords = ["dabam_height_profile"]
outputs = [{"name": "PreProcessor_Data",
"type": ShadowPreProcessorData,
"doc": "PreProcessor Data",
"id": "PreProcessor_Data"}]
want_main_area = 1
want_control_area = 1
MAX_WIDTH = 1320
MAX_HEIGHT = 700
IMAGE_WIDTH = 860
IMAGE_HEIGHT = 645
CONTROL_AREA_WIDTH = 405
TABS_AREA_HEIGHT = 618
xx = None
yy = None
zz = None
entry_number = Setting(1)
shape=Setting(0)
slope_error_from = Setting(0.0)
slope_error_to = Setting(1.5)
dimension_y_from = Setting(0.0)
dimension_y_to = Setting(200.0)
use_undetrended = Setting(0)
step_x = Setting(1.0)
dimension_x = Setting(10.0)
center_y = Setting(1)
modify_y = Setting(0)
new_length = Setting(200.0)
filler_value = Setting(0.0)
scale_factor_y = Setting(1.0)
renormalize_y = Setting(1)
error_type_y = Setting(0)
rms_y = Setting(0.9)
dabam_profile_index = Setting(1)
heigth_profile_file_name = Setting('mirror.dat')
tab=[]
def __init__(self):
super().__init__()
self.runaction = widget.OWAction("Calculate Height Profile", self)
self.runaction.triggered.connect(self.calculate_heigth_profile_ni)
self.addAction(self.runaction)
self.runaction = widget.OWAction("Generate Height Profile File", self)
self.runaction.triggered.connect(self.generate_heigth_profile_file_ni)
self.addAction(self.runaction)
geom = QApplication.desktop().availableGeometry()
self.setGeometry(QRect(round(geom.width() * 0.05),
round(geom.height() * 0.05),
round(min(geom.width() * 0.98, self.MAX_WIDTH)),
round(min(geom.height() * 0.95, self.MAX_HEIGHT))))
self.setMaximumHeight(self.geometry().height())
self.setMaximumWidth(self.geometry().width())
# DABAM INITIALIZATION
self.server = dabam.dabam()
self.server.set_input_silent(True)
gui.separator(self.controlArea)
button_box = oasysgui.widgetBox(self.controlArea, "", addSpace=False, orientation="horizontal")
button = gui.button(button_box, self, "Calculate Height\nProfile", callback=self.calculate_heigth_profile)
button.setFixedHeight(45)
button = gui.button(button_box, self, "Generate Height\nProfile File", callback=self.generate_heigth_profile_file)
font = QFont(button.font())
font.setBold(True)
button.setFont(font)
palette = QPalette(button.palette()) # make a copy of the palette
palette.setColor(QPalette.ButtonText, QColor('Dark Blue'))
button.setPalette(palette) # assign new palette
button.setFixedHeight(45)
button.setFixedWidth(150)
button = gui.button(button_box, self, "Reset Fields", callback=self.call_reset_settings)
font = QFont(button.font())
font.setItalic(True)
button.setFont(font)
palette = QPalette(button.palette()) # make a copy of the palette
palette.setColor(QPalette.ButtonText, QColor('Dark Red'))
button.setPalette(palette) # assign new palette
button.setFixedHeight(45)
gui.separator(self.controlArea)
tabs_setting = gui.tabWidget(self.controlArea)
tabs_setting.setFixedHeight(self.TABS_AREA_HEIGHT)
tabs_setting.setFixedWidth(self.CONTROL_AREA_WIDTH-5)
tab_input = oasysgui.createTabPage(tabs_setting, "DABAM Search Setting")
tab_gener = oasysgui.createTabPage(tabs_setting, "DABAM Generation Setting")
tab_out = oasysgui.createTabPage(tabs_setting, "Output")
manual_box = oasysgui.widgetBox(tab_input, "Manual Entry", addSpace=True, orientation="vertical")
oasysgui.lineEdit(manual_box, self, "entry_number", "Entry Number",
labelWidth=300, valueType=int, orientation="horizontal")
gui.separator(manual_box)
button = gui.button(manual_box, self, "Retrieve Profile", callback=self.retrieve_profile)
button.setFixedHeight(35)
button.setFixedWidth(self.CONTROL_AREA_WIDTH-35)
input_box = oasysgui.widgetBox(tab_input, "Search Parameters", addSpace=True, orientation="vertical")
gui.comboBox(input_box, self, "shape", label="Mirror Shape", labelWidth=300,
items=["All", "Plane", "Cylindrical", "Elliptical", "Toroidal", "Spherical"],
sendSelectedValue=False, orientation="horizontal")
gui.separator(input_box)
input_box_1 = oasysgui.widgetBox(input_box, "", addSpace=True, orientation="horizontal")
oasysgui.lineEdit(input_box_1, self, "slope_error_from", "Slope Error From (" + u"\u03BC" + "rad)",
labelWidth=150, valueType=float, orientation="horizontal")
oasysgui.lineEdit(input_box_1, self, "slope_error_to", "To (" + u"\u03BC" + "rad)",
labelWidth=60, valueType=float, orientation="horizontal")
input_box_2 = oasysgui.widgetBox(input_box, "", addSpace=True, orientation="horizontal")
self.le_dimension_y_from = oasysgui.lineEdit(input_box_2, self, "dimension_y_from", "Mirror Length From",
labelWidth=150, valueType=float, orientation="horizontal")
self.le_dimension_y_to = oasysgui.lineEdit(input_box_2, self, "dimension_y_to", "To",
labelWidth=60, valueType=float, orientation="horizontal")
table_box = oasysgui.widgetBox(tab_input, "Search Results", addSpace=True, orientation="vertical", height=290)
self.overlay_search = Overlay(table_box, self.search_profiles)
self.overlay_search.hide()
button = gui.button(input_box, self, "Search", callback=self.overlay_search.show)
button.setFixedHeight(35)
button.setFixedWidth(self.CONTROL_AREA_WIDTH-35)
gui.comboBox(table_box, self, "use_undetrended", label="Use Undetrended Profile", labelWidth=300,
items=["No", "Yes"], callback=self.table_item_clicked, sendSelectedValue=False, orientation="horizontal")
gui.separator(table_box)
self.scrollarea = QScrollArea()
self.scrollarea.setMinimumWidth(self.CONTROL_AREA_WIDTH-35)
table_box.layout().addWidget(self.scrollarea, alignment=Qt.AlignHCenter)
self.table = QTableWidget(1, 5)
self.table.setAlternatingRowColors(True)
self.table.horizontalHeader().setResizeMode(QHeaderView.Fixed)
self.table.verticalHeader().setVisible(False)
self.table.setColumnWidth(0, 40)
self.table.setColumnWidth(1, 70)
self.table.setColumnWidth(2, 70)
self.table.setColumnWidth(3, 85)
self.table.setColumnWidth(4, 80)
self.table.resizeRowsToContents()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.itemClicked.connect(self.table_item_clicked)
self.scrollarea.setWidget(self.table)
self.scrollarea.setWidgetResizable(1)
output_profile_box = oasysgui.widgetBox(tab_gener, "Surface Generation Parameters", addSpace=True, orientation="vertical", height=270)
self.le_dimension_x = oasysgui.lineEdit(output_profile_box, self, "dimension_x", "Width",
labelWidth=300, valueType=float, orientation="horizontal")
self.le_step_x = oasysgui.lineEdit(output_profile_box, self, "step_x", "Step Width",
labelWidth=300, valueType=float, orientation="horizontal")
gui.comboBox(output_profile_box, self, "center_y", label="Center Profile in the middle of O.E.", labelWidth=300,
items=["No", "Yes"], sendSelectedValue=False, orientation="horizontal")
gui.comboBox(output_profile_box, self, "modify_y", label="Modify Length?", labelWidth=240,
items=["No", "Rescale to new length", "Fit to new length (fill or cut)"], callback=self.set_ModifyY, sendSelectedValue=False, orientation="horizontal")
self.modify_box_1 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=50)
self.modify_box_2 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=50)
oasysgui.lineEdit(self.modify_box_2, self, "scale_factor_y", "Scale Factor", labelWidth=300, valueType=float, orientation="horizontal")
self.modify_box_3 = oasysgui.widgetBox(output_profile_box, "", addSpace=False, orientation="vertical", height=50)
self.le_new_length = oasysgui.lineEdit(self.modify_box_3, self, "new_length", "New Length", labelWidth=300, valueType=float, orientation="horizontal")
oasysgui.lineEdit(self.modify_box_3, self, "filler_value", "Filler Value (if new length > profile length) [nm]", labelWidth=300, valueType=float, orientation="horizontal")
self.set_ModifyY()
gui.comboBox(output_profile_box, self, "renormalize_y", label="Renormalize Length Profile to different RMS", labelWidth=300,
items=["No", "Yes"], callback=self.set_RenormalizeY, sendSelectedValue=False, orientation="horizontal")
self.output_profile_box_1 = oasysgui.widgetBox(output_profile_box, "", addSpace=True, orientation="vertical")
gui.comboBox(self.output_profile_box_1, self, "error_type_y", label="Normalization to", labelWidth=270,
items=["Figure Error (nm)", "Slope Error (" + u"\u03BC" + "rad)"],
sendSelectedValue=False, orientation="horizontal")
oasysgui.lineEdit(self.output_profile_box_1, self, "rms_y", "Rms Value",
labelWidth=300, valueType=float, orientation="horizontal")
self.set_RenormalizeY()
output_box = oasysgui.widgetBox(tab_gener, "Outputs", addSpace=True, orientation="vertical")
select_file_box = oasysgui.widgetBox(output_box, "", addSpace=True, orientation="horizontal")
self.le_heigth_profile_file_name = oasysgui.lineEdit(select_file_box, self, "heigth_profile_file_name", "Output File Name",
labelWidth=120, valueType=str, orientation="horizontal")
gui.button(select_file_box, self, "...", callback=self.selectFile)
self.shadow_output = QTextEdit()
self.shadow_output.setReadOnly(True)
out_box = oasysgui.widgetBox(tab_out, "System Output", addSpace=True, orientation="horizontal", height=500)
out_box.layout().addWidget(self.shadow_output)
gui.rubber(self.controlArea)
self.initializeTabs()
gui.rubber(self.mainArea)
self.overlay_search.raise_()
def resizeEvent(self, event):
self.overlay_search.resize(self.CONTROL_AREA_WIDTH - 15, 290)
event.accept()
def after_change_workspace_units(self):
self.si_to_user_units = 1e2 / self.workspace_units_to_cm
self.horHeaders = ["Entry", "Shape", "Length\n[" + self.workspace_units_label + "]", "Heights St.Dev.\n[nm]", "Slopes St.Dev.\n[" + u"\u03BC" + "rad]"]
self.table.setHorizontalHeaderLabels(self.horHeaders)
self.plot_canvas[0].setGraphXLabel("Y [" + self.workspace_units_label + "]")
self.plot_canvas[1].setGraphXLabel("Y [" + self.workspace_units_label + "]")
self.axis.set_xlabel("X [" + self.workspace_units_label + "]")
self.axis.set_ylabel("Y [" + self.workspace_units_label + "]")
label = self.le_dimension_y_from.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_dimension_y_to.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_dimension_x.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_step_x.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
label = self.le_new_length.parent().layout().itemAt(0).widget()
label.setText(label.text() + " [" + self.workspace_units_label + "]")
def initializeTabs(self):
self.tabs = gui.tabWidget(self.mainArea)
self.tab = [gui.createTabPage(self.tabs, "Info"),
gui.createTabPage(self.tabs, "Heights Profile"),
gui.createTabPage(self.tabs, "Slopes Profile"),
gui.createTabPage(self.tabs, "PSD Heights"),
gui.createTabPage(self.tabs, "CSD Heights"),
gui.createTabPage(self.tabs, "ACF"),
gui.createTabPage(self.tabs, "Generated 2D Profile"),
]
for tab in self.tab:
tab.setFixedHeight(self.IMAGE_HEIGHT)
tab.setFixedWidth(self.IMAGE_WIDTH)
self.plot_canvas = [None, None, None, None, None, None]
self.plot_canvas[0] = PlotWindow(roi=False, control=False, position=True, plugins=False)
self.plot_canvas[0].setDefaultPlotLines(True)
self.plot_canvas[0].setActiveCurveColor(color='darkblue')
self.plot_canvas[0].setGraphYLabel("Z [nm]")
self.plot_canvas[0].setGraphTitle("Heights Profile")
self.plot_canvas[0].setDrawModeEnabled(True, 'rectangle')
self.plot_canvas[0].setZoomModeEnabled(True)
self.plot_canvas[1] = PlotWindow(roi=False, control=False, position=True, plugins=False)
self.plot_canvas[1].setDefaultPlotLines(True)
self.plot_canvas[1].setActiveCurveColor(color='darkblue')
self.plot_canvas[1].setGraphYLabel("Zp [$\mu$rad]")
self.plot_canvas[1].setGraphTitle("Slopes Profile")
self.plot_canvas[1].setDrawModeEnabled(True, 'rectangle')
self.plot_canvas[1].setZoomModeEnabled(True)
self.plot_canvas[2] = PlotWindow(roi=False, control=False, position=True, plugins=False)
self.plot_canvas[2].setDefaultPlotLines(True)
self.plot_canvas[2].setActiveCurveColor(color='darkblue')
self.plot_canvas[2].setGraphXLabel("f [m^-1]")
self.plot_canvas[2].setGraphYLabel("PSD [m^3]")
self.plot_canvas[2].setGraphTitle("Power Spectral Density of Heights Profile")
self.plot_canvas[2].setDrawModeEnabled(True, 'rectangle')
self.plot_canvas[2].setZoomModeEnabled(True)
self.plot_canvas[2].setXAxisLogarithmic(True)
self.plot_canvas[2].setYAxisLogarithmic(True)
self.plot_canvas[3] = PlotWindow(roi=False, control=False, position=True, plugins=False)
self.plot_canvas[3].setDefaultPlotLines(True)
self.plot_canvas[3].setActiveCurveColor(color='darkblue')
self.plot_canvas[3].setGraphXLabel("f [m^-1]")
self.plot_canvas[3].setGraphYLabel("CSD [m^3]")
self.plot_canvas[3].setGraphTitle("Cumulative Spectral Density of Heights Profile")
self.plot_canvas[3].setDrawModeEnabled(True, 'rectangle')
self.plot_canvas[3].setZoomModeEnabled(True)
self.plot_canvas[3].setXAxisLogarithmic(True)
self.plot_canvas[4] = PlotWindow(roi=False, control=False, position=True, plugins=False)
self.plot_canvas[4].setDefaultPlotLines(True)
self.plot_canvas[4].setActiveCurveColor(color='darkblue')
self.plot_canvas[4].setGraphXLabel("Length [m]")
self.plot_canvas[4].setGraphYLabel("ACF")
self.plot_canvas[4].setGraphTitle("Autocovariance Function of Heights Profile")
self.plot_canvas[4].setDrawModeEnabled(True, 'rectangle')
self.plot_canvas[4].setZoomModeEnabled(True)
self.figure = Figure(figsize=(self.IMAGE_HEIGHT, self.IMAGE_HEIGHT)) # QUADRATA!
self.figure.patch.set_facecolor('white')
self.axis = self.figure.add_subplot(111, projection='3d')
self.axis.set_zlabel("Z [nm]")
self.plot_canvas[5] = FigureCanvasQTAgg(self.figure)
self.profileInfo = QTextEdit()
self.profileInfo.setReadOnly(True)
self.profileInfo.setMinimumHeight(self.IMAGE_HEIGHT-5)
self.profileInfo.setMaximumHeight(self.IMAGE_HEIGHT-5)
self.profileInfo.setMinimumWidth(310)
self.profileInfo.setMaximumWidth(310)
profile_box = oasysgui.widgetBox(self.tab[0], "", addSpace=True, orientation="horizontal", height = self.IMAGE_HEIGHT, width=320)
profile_box.layout().addWidget(self.profileInfo)
for index in range(0, 6):
self.tab[index+1].layout().addWidget(self.plot_canvas[index])
self.tabs.setCurrentIndex(1)
def plot_dabam_graph(self, plot_canvas_index, curve_name, x_values, y_values, xtitle, ytitle, color='blue', replace=True):
self.plot_canvas[plot_canvas_index].addCurve(x_values, y_values, curve_name, symbol='', color=color, replace=replace) #'+', '^', ','
self.plot_canvas[plot_canvas_index].setGraphXLabel(xtitle)
self.plot_canvas[plot_canvas_index].setGraphYLabel(ytitle)
self.plot_canvas[plot_canvas_index].replot()
def set_ModifyY(self):
self.modify_box_1.setVisible(self.modify_y == 0)
self.modify_box_2.setVisible(self.modify_y == 1)
self.modify_box_3.setVisible(self.modify_y == 2)
def set_RenormalizeY(self):
self.output_profile_box_1.setVisible(self.renormalize_y==1)
def table_item_clicked(self):
if self.table.selectionModel().hasSelection():
if not self.table.rowCount() == 0:
if not self.table.item(0, 0) is None:
row = self.table.selectionModel().selectedRows()[0].row()
self.entry_number = int(self.table.item(row, 0).text())
self.retrieve_profile()
def retrieve_profile(self):
try:
if self.entry_number is None or self.entry_number <= 0:
raise Exception("Entry number should be a strictly positive integer number")
self.server.load(self.entry_number)
self.profileInfo.setText(self.server.info_profiles())
self.plot_canvas[0].setGraphTitle(
"Heights Profile. St.Dev.=%.3f nm" % (self.server.stdev_profile_heights() * 1e9))
self.plot_canvas[1].setGraphTitle(
"Slopes Profile. St.Dev.=%.3f $\mu$rad" % (self.server.stdev_profile_slopes() * 1e6))
if self.use_undetrended == 0:
self.plot_dabam_graph(0, "heights_profile", self.si_to_user_units * self.server.y,
1e9 * self.server.zHeights, "Y [" + self.workspace_units_label + "]", "Z [nm]")
self.plot_dabam_graph(1, "slopes_profile", self.si_to_user_units * self.server.y, 1e6 * self.server.zSlopes,
"Y [" + self.workspace_units_label + "]", "Zp [$\mu$rad]")
else:
self.plot_dabam_graph(0, "heights_profile", self.si_to_user_units * self.server.y,
1e9 * self.server.zHeightsUndetrended, "Y [" + self.workspace_units_label + "]",
"Z [nm]")
self.plot_dabam_graph(1, "slopes_profile", self.si_to_user_units * self.server.y,
1e6 * self.server.zSlopesUndetrended, "Y [" + self.workspace_units_label + "]",
"Zp [$\mu$rad]")
y = self.server.f ** (self.server.powerlaw["hgt_pendent"]) * 10 ** self.server.powerlaw["hgt_shift"]
i0 = self.server.powerlaw["index_from"]
i1 = self.server.powerlaw["index_to"]
beta = -self.server.powerlaw["hgt_pendent"]
self.plot_canvas[2].setGraphTitle(
"Power Spectral Density of Heights Profile (beta=%.2f,Df=%.2f)" % (beta, (5 - beta) / 2))
self.plot_dabam_graph(2, "psd_heights_2", self.server.f, self.server.psdHeights, "f [m^-1]", "PSD [m^3]")
self.plot_dabam_graph(2, "psd_heights_1", self.server.f, y, "f [m^-1]", "PSD [m^3]", color='green',
replace=False)
self.plot_dabam_graph(2, "psd_heights_3", self.server.f[i0:i1], y[i0:i1], "f [m^-1]", "PSD [m^3]", color='red',
replace=False)
self.plot_dabam_graph(3, "csd", self.server.f, self.server.csd_heights(), "f [m^-1]", "CSD [m^3]")
c1, c2, c3 = dabam.autocorrelationfunction(self.server.y, self.server.zHeights)
self.plot_canvas[4].setGraphTitle(
"Autocovariance Function of Heights Profile.\nAutocorrelation Length (ACF=0.5)=%.3f m" % (c3))
self.plot_dabam_graph(4, "acf", c1[0:-1], c2, "Length [m]", "Heights Autocovariance")
# surface error removal
if not self.zz is None and not self.yy is None and not self.xx is None:
self.xx = None
self.yy = None
self.zz = None
self.axis.set_title("")
self.axis.clear()
self.plot_canvas[5].draw()
if (self.tabs.currentIndex()==6): self.tabs.setCurrentIndex(1)
except Exception as exception:
QMessageBox.critical(self, "Error",
exception.args[0],
QMessageBox.Ok)
#raise exception
def search_profiles(self):
try:
self.table.itemClicked.disconnect(self.table_item_clicked)
self.table.clear()
row_count = self.table.rowCount()
for n in range(0, row_count):
self.table.removeRow(0)
self.table.setHorizontalHeaderLabels(self.horHeaders)
profiles = dabam.dabam_summary_dictionary(surface=self.get_dabam_shape(),
slp_err_from=self.slope_error_from*1e-6,
slp_err_to=self.slope_error_to*1e-6,
length_from=self.dimension_y_from / self.si_to_user_units,
length_to=self.dimension_y_to / self.si_to_user_units)
for index in range(0, len(profiles)):
self.table.insertRow(0)
for index in range(0, len(profiles)):
table_item = QTableWidgetItem(str(profiles[index]["entry"]))
table_item.setTextAlignment(Qt.AlignCenter)
self.table.setItem(index, 0, table_item)
table_item = QTableWidgetItem(str(profiles[index]["surface"]))
table_item.setTextAlignment(Qt.AlignLeft)
self.table.setItem(index, 1, table_item)
table_item = QTableWidgetItem(str(numpy.round(profiles[index]["length"]*self.si_to_user_units, 3)))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(index, 2, table_item)
table_item = QTableWidgetItem(str(numpy.round(profiles[index]["hgt_err"]*1e9, 3)))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(index, 3, table_item)
table_item = QTableWidgetItem(str(numpy.round(profiles[index]["slp_err"]*1e6, 3)))
table_item.setTextAlignment(Qt.AlignRight)
self.table.setItem(index, 4, table_item)
self.table.setHorizontalHeaderLabels(self.horHeaders)
self.table.resizeRowsToContents()
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.itemClicked.connect(self.table_item_clicked)
self.overlay_search.hide()
except Exception as exception:
self.overlay_search.hide()
QMessageBox.critical(self, "Error",
exception.args[0],
QMessageBox.Ok)
def get_dabam_shape(self):
if self.shape == 0: return None
elif self.shape == 1: return "plane"
elif self.shape == 2: return "cylindrical"
elif self.shape == 3: return "elliptical"
elif self.shape == 4: return "toroidal"
elif self.shape == 5: return "spherical"
def calculate_heigth_profile_ni(self):
self.calculate_heigth_profile(not_interactive_mode=True)
def calculate_heigth_profile(self, not_interactive_mode=False):
try:
if self.server.y is None: raise Exception("No Profile Selected")
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
self.check_fields()
combination = "EF"
if self.modify_y == 2:
profile_1D_y_x_temp = self.si_to_user_units * self.server.y
if self.use_undetrended == 0: profile_1D_y_y_temp = self.si_to_user_units * self.server.zHeights
else: profile_1D_y_y_temp = self.si_to_user_units * self.server.zHeightsUndetrended
first_coord = profile_1D_y_x_temp[0]
second_coord = profile_1D_y_x_temp[1]
last_coord = profile_1D_y_x_temp[-1]
step = numpy.abs(second_coord - first_coord)
length = numpy.abs(last_coord - first_coord)
n_points_old = len(profile_1D_y_x_temp)
if self.new_length > length:
difference = self.new_length - length
n_added_points = int(difference/step)
if difference % step == 0:
n_added_points += 1
if n_added_points % 2 != 0:
n_added_points += 1
profile_1D_y_x = numpy.arange(n_added_points + n_points_old) * step
profile_1D_y_y = numpy.ones(n_added_points + n_points_old) * self.filler_value * 1e-9 * self.si_to_user_units
profile_1D_y_y[int(n_added_points/2) : n_points_old + int(n_added_points/2)] = profile_1D_y_y_temp
elif self.new_length < length:
difference = length - self.new_length
n_removed_points = int(difference/step)
if difference % step == 0:
n_removed_points -= 1
if n_removed_points % 2 != 0:
n_removed_points -= 1
if n_removed_points >= 2:
profile_1D_y_x = profile_1D_y_x_temp[0 : (n_points_old - n_removed_points)]
profile_1D_y_y = profile_1D_y_y_temp[(int(n_removed_points/2) - 1) : (n_points_old - int(n_removed_points/2) - 1)]
else:
profile_1D_y_x = profile_1D_y_x_temp
profile_1D_y_y = profile_1D_y_y_temp
else:
profile_1D_y_x = profile_1D_y_x_temp
profile_1D_y_y = profile_1D_y_y_temp
else:
if self.modify_y == 0:
profile_1D_y_x = self.si_to_user_units * self.server.y
elif self.modify_y == 1:
profile_1D_y_x = self.si_to_user_units * self.server.y * self.scale_factor_y
if self.use_undetrended == 0: profile_1D_y_y = self.si_to_user_units * self.server.zHeights
else: profile_1D_y_y = self.si_to_user_units * self.server.zHeightsUndetrended
if self.center_y:
first_coord = profile_1D_y_x[0]
last_coord = profile_1D_y_x[-1]
length = numpy.abs(last_coord - first_coord)
profile_1D_y_x_temp = numpy.linspace(-length/2, length/2, len(profile_1D_y_x))
profile_1D_y_x = profile_1D_y_x_temp
if self.renormalize_y == 0:
rms_y = None
else:
if self.error_type_y == profiles_simulation.FIGURE_ERROR:
rms_y = self.si_to_user_units * self.rms_y * 1e-9 # from nm to user units
else:
rms_y = self.rms_y * 1e-6 # from urad to rad
xx, yy, zz = profiles_simulation.simulate_profile_2D(combination = combination,
error_type_l = self.error_type_y,
rms_l = rms_y,
x_l = profile_1D_y_x,
y_l = profile_1D_y_y,
mirror_width = self.dimension_x,
step_w = self.step_x,
rms_w = 0.0)
self.xx = xx
self.yy = yy
self.zz = zz # in user units
self.axis.clear()
x_to_plot, y_to_plot = numpy.meshgrid(xx, yy)
z_to_plot = zz * 1e9 / self.si_to_user_units #nm
self.axis.plot_surface(x_to_plot, y_to_plot, z_to_plot,
rstride=1, cstride=1, cmap=cm.autumn, linewidth=0.5, antialiased=True)
sloperms = profiles_simulation.slopes(zz.T, xx, yy, return_only_rms=1)
title = ' Slope error rms in X direction: %f $\mu$rad' % (sloperms[0]*1e6) + '\n' + \
' Slope error rms in Y direction: %f $\mu$rad' % (sloperms[1]*1e6)
self.axis.set_xlabel("X [" + self.workspace_units_label + "]")
self.axis.set_ylabel("Y [" + self.workspace_units_label + "]")
self.axis.set_zlabel("Z [nm]")
self.axis.set_title(title)
self.axis.mouse_init()
if not not_interactive_mode:
try:
self.plot_canvas[5].draw()
except:
pass
self.tabs.setCurrentIndex(6)
QMessageBox.information(self, "QMessageBox.information()",
"Height Profile calculated: if the result is satisfactory,\nclick \'Generate Height Profile File\' to complete the operation ",
QMessageBox.Ok)
except Exception as exception:
QMessageBox.critical(self, "Error",
exception.args[0],
QMessageBox.Ok)
#raise exception
def generate_heigth_profile_file_ni(self):
self.generate_heigth_profile_file(not_interactive_mode=True)
def generate_heigth_profile_file(self, not_interactive_mode=False):
if not self.zz is None and not self.yy is None and not self.xx is None:
try:
congruence.checkDir(self.heigth_profile_file_name)
sys.stdout = EmittingStream(textWritten=self.writeStdOut)
ST.write_shadow_surface(self.zz, self.xx, self.yy, outFile=congruence.checkFileName(self.heigth_profile_file_name))
if not not_interactive_mode:
QMessageBox.information(self, "QMessageBox.information()",
"Height Profile file " + self.heigth_profile_file_name + " written on disk",
QMessageBox.Ok)
if self.modify_y == 0:
dimension_y = self.si_to_user_units * (self.server.y[-1] - self.server.y[0])
if self.modify_y == 1:
dimension_y = self.si_to_user_units * (self.server.y[-1] - self.server.y[0]) * self.scale_factor_y
elif self.modify_y == 2:
dimension_y = self.new_length
self.send("PreProcessor_Data", ShadowPreProcessorData(error_profile_data_file=self.heigth_profile_file_name,
error_profile_x_dim=self.dimension_x,
error_profile_y_dim=dimension_y))
except Exception as exception:
QMessageBox.critical(self, "Error",
exception.args[0],
QMessageBox.Ok)
def call_reset_settings(self):
if ConfirmDialog.confirmed(parent=self, message="Confirm Reset of the Fields?"):
try:
self.resetSettings()
except:
pass
def check_fields(self):
self.dimension_x = congruence.checkStrictlyPositiveNumber(self.dimension_x, "Dimension X")
self.step_x = congruence.checkStrictlyPositiveNumber(self.step_x, "Step X")
if self.step_x > self.dimension_x/2:
raise Exception("Step Width should be smaller than or equal to Width/2")
if self.modify_y == 1:
self.scale_factor_y = congruence.checkStrictlyPositiveNumber(self.scale_factor_y, "Scale Factor")
elif self.modify_y == 2:
self.new_length = congruence.checkStrictlyPositiveNumber(self.new_length, "New Length")
if self.renormalize_y == 1:
self.rms_y = congruence.checkPositiveNumber(self.rms_y, "Rms Y")
congruence.checkDir(self.heigth_profile_file_name)
def writeStdOut(self, text):
cursor = self.shadow_output.textCursor()
cursor.movePosition(QTextCursor.End)
cursor.insertText(text)
self.shadow_output.setTextCursor(cursor)
self.shadow_output.ensureCursorVisible()
def selectFile(self):
self.le_heigth_profile_file_name.setText(oasysgui.selectFileFromDialog(self, self.heigth_profile_file_name, "Select Output File", file_extension_filter="Data Files (*.dat)"))
class Search(QDialog):
def __init__(self, parent=None):
super(Search, self).__init__(parent=parent)
self.create_layout()
self.create_connections()
def create_layout(self):
label = QLabel("Your query:")
self.query_edit = QLineEdit()
self.find_button = QPushButton("Search")
self.get_button = QPushButton("Get selected books")
self.table = QTableWidget()
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(['Select', 'Name', 'URL'])
hbox = QHBoxLayout()
hbox.addWidget(label)
hbox.addWidget(self.query_edit)
hbox.addWidget(self.find_button)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(self.table)
vbox.addWidget(self.get_button)
self.setLayout(vbox)
def create_connections(self):
self.connect(self.find_button, SIGNAL('clicked()'), self.render_result)
self.connect(self.get_button, SIGNAL('clicked()'), self.download)
def render_result(self):
query = self.query_edit.text()
if not query:
return
self.feed = FeedBooks()
response = self.feed.search(str(query))
if not response:
QMessageBox.critical(self, 'Error', 'Could not get any result')
return
self.table.clear()
self.table.setHorizontalHeaderLabels(['Select', 'Title', 'URL'])
self.table.setRowCount(len(response[1]))
for i, name in enumerate(zip(response[1], response[3])):
item = QTableWidgetItem(1)
item.data(Qt.CheckStateRole)
item.setCheckState(Qt.Checked)
self.table.setItem(i, 0, item)
for j in range(2):
item = QTableWidgetItem(name[j])
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.table.setItem(i, j+1, item)
self.table.resizeColumnsToContents()
def download(self):
rows = self.table.rowCount()
progress = QProgressDialog("Downloading books...", "Abort download", 0,
rows, self)
progress.setWindowModality(Qt.WindowModal)
progress.show()
to_download = [self.table.item(row, 2).text() for row in range(rows) if
self.table.item(row, 0).checkState() == Qt.Checked]
for i, book in enumerate(to_download):
progress.setValue(i)
book_id = self.feed.download(str(book))
if not book_id:
QMessageBox.critical(self, 'Error', 'Could not download the '
'book')
elif book_id != -1:
book = Book(book_id)
insert_library(book)
if progress.wasCanceled():
break
progress.setValue(rows)
progress.close()
self.parent().library.refresh()
class Main(plugin.Plugin):
" Main Class "
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.scriptPath, self.scriptArgs = "", []
self.profilerPath, self.tempPath = profilerPath, tempPath
self.output = " ERROR: FAIL: No output ! "
self.process = QProcess()
self.process.finished.connect(self.on_process_finished)
self.process.error.connect(self.on_process_error)
self.tabWidget, self.stat = QTabWidget(), QWidget()
self.tabWidget.tabCloseRequested.connect(lambda:
self.tabWidget.setTabPosition(1)
if self.tabWidget.tabPosition() == 0
else self.tabWidget.setTabPosition(0))
self.tabWidget.setStyleSheet('QTabBar{font-weight:bold;}')
self.tabWidget.setMovable(True)
self.tabWidget.setTabsClosable(True)
self.vboxlayout1 = QVBoxLayout(self.stat)
self.hboxlayout1 = QHBoxLayout()
self.filterTableLabel = QLabel("<b>Type to Search : </b>", self.stat)
self.hboxlayout1.addWidget(self.filterTableLabel)
self.filterTableLineEdit = QLineEdit(self.stat)
self.filterTableLineEdit.setPlaceholderText(' Type to Search . . . ')
self.hboxlayout1.addWidget(self.filterTableLineEdit)
self.filterHintTableLabel = QLabel(" ? ", self.stat)
self.hboxlayout1.addWidget(self.filterHintTableLabel)
self.vboxlayout1.addLayout(self.hboxlayout1)
self.tableWidget = QTableWidget(self.stat)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setColumnCount(8)
self.tableWidget.setRowCount(2)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(5, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(6, item)
item = QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(7, item)
self.tableWidget.itemDoubleClicked.connect(
self.on_tableWidget_itemDoubleClicked)
self.vboxlayout1.addWidget(self.tableWidget)
self.tabWidget.addTab(self.stat, " ? ")
self.source = QWidget()
self.gridlayout = QGridLayout(self.source)
self.scintillaWarningLabel = QLabel(
"QScintilla is not installed!. Falling back to basic text edit!.",
self.source)
self.gridlayout.addWidget(self.scintillaWarningLabel, 1, 0, 1, 2)
self.sourceTreeWidget = QTreeWidget(self.source)
self.sourceTreeWidget.setAlternatingRowColors(True)
self.sourceTreeWidget.itemActivated.connect(
self.on_sourceTreeWidget_itemActivated)
self.sourceTreeWidget.itemClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.sourceTreeWidget.itemDoubleClicked.connect(
self.on_sourceTreeWidget_itemClicked)
self.gridlayout.addWidget(self.sourceTreeWidget, 0, 0, 1, 1)
self.sourceTextEdit = QTextEdit(self.source)
self.sourceTextEdit.setReadOnly(True)
self.gridlayout.addWidget(self.sourceTextEdit, 0, 1, 1, 1)
self.tabWidget.addTab(self.source, " ? ")
self.result = QWidget()
self.vlayout = QVBoxLayout(self.result)
self.globalStatGroupBox = QGroupBox(self.result)
self.hboxlayout = QHBoxLayout(self.globalStatGroupBox)
self.totalTimeLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.totalTimeLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.totalTimeLcdNumber.setNumDigits(7)
self.totalTimeLcdNumber.display(1000000)
self.totalTimeLcdNumber.setFrameShape(QFrame.StyledPanel)
self.totalTimeLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.totalTimeLcdNumber)
self.tTimeLabel = QLabel("<b>Total Time (Sec)</b>",
self.globalStatGroupBox)
self.tTimeLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.tTimeLabel)
self.numCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.numCallLcdNumber.setNumDigits(7)
self.numCallLcdNumber.display(1000000)
self.numCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.numCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.numCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.numCallLcdNumber)
self.numCallLabel = QLabel("<b>Number of calls</b>",
self.globalStatGroupBox)
self.numCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.numCallLabel)
self.primCallLcdNumber = QLCDNumber(self.globalStatGroupBox)
self.primCallLcdNumber.setSegmentStyle(QLCDNumber.Filled)
self.primCallLcdNumber.setFrameShape(QFrame.StyledPanel)
self.primCallLcdNumber.setNumDigits(7)
self.primCallLcdNumber.display(1000000)
self.primCallLcdNumber.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.hboxlayout.addWidget(self.primCallLcdNumber)
self.primCallLabel = QLabel("<b>Primitive calls (%)</b>",
self.globalStatGroupBox)
self.primCallLabel.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Minimum)
self.hboxlayout.addWidget(self.primCallLabel)
self.vlayout.addWidget(self.globalStatGroupBox)
try:
from PyKDE4.kdeui import KRatingWidget
self.rating = KRatingWidget(self.globalStatGroupBox)
self.rating.setToolTip('Profiling Performance Rating')
except ImportError:
pass
self.tabWidget.addTab(self.result, " Get Results ! ")
self.resgraph = QWidget()
self.vlayout2 = QVBoxLayout(self.result)
self.graphz = QGroupBox(self.resgraph)
self.hboxlayout2 = QHBoxLayout(self.graphz)
try:
from PyKDE4.kdeui import KLed
KLed(self.graphz)
except ImportError:
pass
self.hboxlayout2.addWidget(QLabel('''
Work in Progress :) Not Ready Yet'''))
self.vlayout2.addWidget(self.graphz)
self.tabWidget.addTab(self.resgraph, " Graphs and Charts ")
self.pathz = QWidget()
self.vlayout3 = QVBoxLayout(self.pathz)
self.patz = QGroupBox(self.pathz)
self.hboxlayout3 = QVBoxLayout(self.patz)
self.profilepath = QLineEdit(profilerPath)
self.getprofile = QPushButton(QIcon.fromTheme("document-open"), 'Open')
self.getprofile.setToolTip('Dont touch if you dont know what are doing')
self.getprofile.clicked.connect(lambda: self.profilepath.setText(str(
QFileDialog.getOpenFileName(self.patz, ' Open the profile.py file ',
path.expanduser("~"), ';;(profile.py)'))))
self.hboxlayout3.addWidget(QLabel(
'<center><b>Profile.py Python Library Full Path:</b></center>'))
self.hboxlayout3.addWidget(self.profilepath)
self.hboxlayout3.addWidget(self.getprofile)
self.argGroupBox = QGroupBox(self.pathz)
self.hbxlayout = QHBoxLayout(self.argGroupBox)
self.argLineEdit = QLineEdit(self.argGroupBox)
self.argLineEdit.setToolTip('Not touch if you dont know what are doing')
self.argLineEdit.setPlaceholderText(
'Dont touch if you dont know what are doing')
self.hbxlayout.addWidget(QLabel('<b>Additional Profile Arguments:</b>'))
self.hbxlayout.addWidget(self.argLineEdit)
self.hboxlayout3.addWidget(self.argGroupBox)
self.vlayout3.addWidget(self.patz)
self.tabWidget.addTab(self.pathz, " Paths and Configs ")
self.outp = QWidget()
self.vlayout4 = QVBoxLayout(self.outp)
self.outgro = QGroupBox(self.outp)
self.outgro.setTitle(" MultiProcessing Output Logs ")
self.hboxlayout4 = QVBoxLayout(self.outgro)
self.outputlog = QTextEdit()
self.outputlog.setText('''
I do not fear computers, I fear the lack of them. -Isaac Asimov ''')
self.hboxlayout4.addWidget(self.outputlog)
self.vlayout4.addWidget(self.outgro)
self.tabWidget.addTab(self.outp, " Logs ")
self.actionNew_profiling = QAction(QIcon.fromTheme("document-new"),
'New Profiling', self)
self.actionLoad_profile = QAction(QIcon.fromTheme("document-open"),
'Open Profiling', self)
self.actionClean = QAction(QIcon.fromTheme("edit-clear"), 'Clean', self)
self.actionClean.triggered.connect(lambda: self.clearContent)
self.actionAbout = QAction(QIcon.fromTheme("help-about"), 'About', self)
self.actionAbout.triggered.connect(lambda: QMessageBox.about(self.dock,
__doc__, ', '.join((__doc__, __license__, __author__, __email__))))
self.actionSave_profile = QAction(QIcon.fromTheme("document-save"),
'Save Profiling', self)
self.actionManual = QAction(QIcon.fromTheme("help-contents"),
'Help', self)
self.actionManual.triggered.connect(lambda:
open_new_tab('http://docs.python.org/library/profile.html'))
self.tabWidget.setCurrentIndex(2)
self.globalStatGroupBox.setTitle("Global Statistics")
item = self.tableWidget.horizontalHeaderItem(0)
item.setText("Number of Calls")
item = self.tableWidget.horizontalHeaderItem(1)
item.setText("Total Time")
item = self.tableWidget.horizontalHeaderItem(2)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(3)
item.setText("Cumulative Time")
item = self.tableWidget.horizontalHeaderItem(4)
item.setText("Per Call")
item = self.tableWidget.horizontalHeaderItem(5)
item.setText("Filename")
item = self.tableWidget.horizontalHeaderItem(6)
item.setText("Line")
item = self.tableWidget.horizontalHeaderItem(7)
item.setText("Function")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.stat),
"Statistics per Function")
self.sourceTreeWidget.headerItem().setText(0, "Source files")
self.tabWidget.setTabText(self.tabWidget.indexOf(self.source),
"Sources Navigator")
#######################################################################
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(self.tabWidget)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
QToolBar(self.dock).addActions((self.actionNew_profiling,
self.actionClean, self.actionSave_profile, self.actionLoad_profile,
self.actionManual, self.actionAbout))
self.actionNew_profiling.triggered.connect(
self.on_actionNew_profiling_triggered)
self.actionLoad_profile.triggered.connect(
self.on_actionLoad_profile_triggered)
self.actionSave_profile.triggered.connect(
self.on_actionSave_profile_triggered)
self.locator.get_service('misc').add_widget(self.dock,
QIcon.fromTheme("document-open-recent"), __doc__)
if QSCI:
# Scintilla source editor management
self.scintillaWarningLabel.setText(' QScintilla is Ready ! ')
layout = self.source.layout()
layout.removeWidget(self.sourceTextEdit)
self.sourceTextEdit = Qsci.QsciScintilla(self.source)
layout.addWidget(self.sourceTextEdit, 0, 1)
doc = self.sourceTextEdit
doc.setLexer(Qsci.QsciLexerPython(self.sourceTextEdit))
doc.setReadOnly(True)
doc.setEdgeMode(Qsci.QsciScintilla.EdgeLine)
doc.setEdgeColumn(80)
doc.setEdgeColor(QColor("#FF0000"))
doc.setFolding(Qsci.QsciScintilla.BoxedTreeFoldStyle)
doc.setBraceMatching(Qsci.QsciScintilla.SloppyBraceMatch)
doc.setCaretLineVisible(True)
doc.setMarginLineNumbers(1, True)
doc.setMarginWidth(1, 25)
doc.setTabWidth(4)
doc.setEolMode(Qsci.QsciScintilla.EolUnix)
self.marker = {}
for color in COLORS:
mnr = doc.markerDefine(Qsci.QsciScintilla.Background)
doc.setMarkerBackgroundColor(color, mnr)
self.marker[color] = mnr
self.currentSourcePath = None
# Connect table and tree filter edit signal to unique slot
self.filterTableLineEdit.textEdited.connect(
self.on_filterLineEdit_textEdited)
# Timer to display filter hint message
self.filterHintTimer = QTimer(self)
self.filterHintTimer.setSingleShot(True)
self.filterHintTimer.timeout.connect(self.on_filterHintTimer_timeout)
# Timer to start search
self.filterSearchTimer = QTimer(self)
self.filterSearchTimer.setSingleShot(True)
self.filterSearchTimer.timeout.connect(
self.on_filterSearchTimer_timeout)
self.tabLoaded = {}
for i in range(10):
self.tabLoaded[i] = False
self.backgroundTreeMatchedItems = {}
self.resizeWidgetToContent(self.tableWidget)
def on_actionNew_profiling_triggered(self):
self.clearContent()
self.scriptPath = str(QFileDialog.getOpenFileName(self.dock,
"Choose your script to profile", path.expanduser("~"),
"Python (*.py *.pyw)"))
commandLine = [self.profilerPath, "-o", self.tempPath,
self.scriptPath] + self.scriptArgs
commandLine = " ".join(commandLine)
##if self.termCheckBox.checkState() == Qt.Checked:
#termList = ["xterm", "aterm"]
#for term in termList:
#termPath = which(term)
#if termPath:
#break
#commandLine = """%s -e "%s ; echo 'Press ENTER Exit' ; read" """ \
#% (termPath, commandLine)
self.process.start(commandLine)
if not self.process.waitForStarted():
print((" ERROR: {} failed!".format(commandLine)))
return
def on_process_finished(self, exitStatus):
' whan the process end '
print((" INFO: OK: QProcess is %s" % self.process.exitCode()))
self.output = self.process.readAll().data()
if not self.output:
self.output = " ERROR: FAIL: No output ! "
self.outputlog.setText(self.output + str(self.process.exitCode()))
if path.exists(self.tempPath):
self.setStat(self.tempPath)
remove(self.tempPath)
else:
self.outputlog.setText(" ERROR: QProcess FAIL: Profiling failed.")
self.tabWidget.setCurrentIndex(2)
def on_process_error(self, error):
' when the process fail, I hope you never see this '
print(" ERROR: QProcess FAIL: Profiler Dead, wheres your God now ? ")
if error == QProcess.FailedToStart:
self.outputlog.setText(" ERROR: FAIL: Profiler execution failed ")
elif error == QProcess.Crashed:
self.outputlog.setText(" ERROR: FAIL: Profiler execution crashed ")
else:
self.outputlog.setText(" ERROR: FAIL: Profiler unknown error ")
def on_actionLoad_profile_triggered(self):
"""Load a previous profile sessions"""
statPath = str(QFileDialog.getOpenFileName(self.dock,
"Open profile dump", path.expanduser("~"), "Profile file (*)"))
if statPath:
self.clearContent()
print(' INFO: OK: Loading profiling from ' + statPath)
self.setStat(statPath)
def on_actionSave_profile_triggered(self):
"""Save a profile sessions"""
statPath = str(QFileDialog.getSaveFileName(self.dock,
"Save profile dump", path.expanduser("~"), "Profile file (*)"))
if statPath:
#TODO: handle error case and give feelback to user
print(' INFO: OK: Saving profiling to ' + statPath)
self.stat.save(statPath)
#=======================================================================#
# Common parts #
#=======================================================================#
def on_tabWidget_currentChanged(self, index):
"""slot for tab change"""
# Kill search and hint timer if running to avoid cross effect
for timer in (self.filterHintTimer, self.filterSearchTimer):
if timer.isActive():
timer.stop()
if not self.stat:
#No stat loaded, nothing to do
return
self.populateTable()
self.populateSource()
def on_filterLineEdit_textEdited(self, text):
"""slot for filter change (table or tree"""
if self.filterSearchTimer.isActive():
# Already runnning, stop it
self.filterSearchTimer.stop()
# Start timer
self.filterSearchTimer.start(300)
def on_filterHintTimer_timeout(self):
"""Timeout to warn user about text length"""
print("timeout")
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
label = self.filterHintTableLabel
label.setText("Type > 2 characters to search")
def on_filterSearchTimer_timeout(self):
"""timeout to start search"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
text = self.filterTableLineEdit.text()
label = self.filterHintTableLabel
edit = self.filterTableLineEdit
widget = self.tableWidget
else:
print("Unknow tab for filterSearch timeout !")
print(("do search for %s" % text))
if not len(text):
# Empty keyword, just clean all
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
self.warnUSer(True, edit)
self.clearSearch()
return
if len(text) < 2:
# Don't filter if text is too short and tell it to user
self.filterHintTimer.start(600)
return
else:
if self.filterHintTimer.isActive():
self.filterHintTimer.stop()
label.setText(" ? ")
# Search
self.clearSearch()
matchedItems = []
if tab == TAB_FUNCTIONSTAT:
# Find items
matchedItems = widget.findItems(text, Qt.MatchContains)
widget.setSortingEnabled(False)
matchedRows = [item.row() for item in matchedItems]
# Hide matched items
header = widget.verticalHeader()
for row in range(widget.rowCount()):
if row not in matchedRows:
header.hideSection(row)
widget.setSortingEnabled(True)
else:
print(" Unknow tab for filterSearch timeout ! ")
print(("got %s members" % len(matchedItems)))
self.warnUSer(matchedItems, edit)
self.resizeWidgetToContent(widget)
def resizeWidgetToContent(self, widget):
"""Resize all columns according to content"""
for i in range(widget.columnCount()):
widget.resizeColumnToContents(i)
def clearSearch(self):
"""Clean search result
For table, show all items
For tree, remove colored items"""
tab = self.tabWidget.currentIndex()
if tab == TAB_FUNCTIONSTAT:
header = self.tableWidget.verticalHeader()
if header.hiddenSectionCount():
for i in range(header.count()):
if header.isSectionHidden(i):
header.showSection(i)
def clearContent(self):
# Clear tabs
self.tableWidget.clearContents()
self.sourceTreeWidget.clear()
# Reset LCD numbers
for lcdNumber in (self.totalTimeLcdNumber, self.numCallLcdNumber,
self.primCallLcdNumber):
lcdNumber.display(1000000)
# Reset stat
self.pstat = None
# Disable save as menu
self.actionSave_profile.setEnabled(False)
# Mark all tabs as unloaded
for i in range(10):
self.tabLoaded[i] = False
def warnUSer(self, result, inputWidget):
palette = inputWidget.palette()
if result:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 255, 255))
else:
palette.setColor(QPalette.Normal, QPalette.Base,
QColor(255, 136, 138))
inputWidget.setPalette(palette)
inputWidget.update()
def setStat(self, statPath):
self.stat = Stat(path=statPath)
# Global stat update
self.totalTimeLcdNumber.display(self.stat.getTotalTime())
self.numCallLcdNumber.display(self.stat.getCallNumber())
self.primCallLcdNumber.display(self.stat.getPrimitiveCallRatio())
# Refresh current tab
self.on_tabWidget_currentChanged(self.tabWidget.currentIndex())
# Activate save as menu
self.actionSave_profile.setEnabled(True)
try:
self.rating.setMaxRating(10)
self.rating.setRating(
int(self.stat.getPrimitiveCallRatio()) / 10 - 1)
except:
pass
#========================================================================#
# Statistics table #
#=======================================================================#
def populateTable(self):
row = 0
rowCount = self.stat.getStatNumber()
progress = QProgressDialog("Populating statistics table...",
"Abort", 0, 2 * rowCount)
self.tableWidget.setSortingEnabled(False)
self.tableWidget.setRowCount(rowCount)
progress.setWindowModality(Qt.WindowModal)
for (key, value) in self.stat.getStatItems():
#ncalls
item = StatTableWidgetItem(str(value[0]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_NCALLS, item)
colorTableItem(item, self.stat.getCallNumber(), value[0])
#total time
item = StatTableWidgetItem(str(value[2]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[2])
#per call (total time)
if value[0] != 0:
tPerCall = str(value[2] / value[0])
cPerCall = str(value[3] / value[0])
else:
tPerCall = ""
cPerCall = ""
item = StatTableWidgetItem(tPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_TPERCALL, item)
colorTableItem(item, 100.0 * self.stat.getTotalTime() /
self.stat.getCallNumber(), tPerCall)
#per call (cumulative time)
item = StatTableWidgetItem(cPerCall)
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CPERCALL, item)
colorTableItem(item, 100.0 * self.stat.getTotalTime() /
self.stat.getCallNumber(), cPerCall)
#cumulative time
item = StatTableWidgetItem(str(value[3]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_CTIME, item)
colorTableItem(item, self.stat.getTotalTime(), value[3])
#Filename
self.tableWidget.setItem(row, STAT_FILENAME,
StatTableWidgetItem(str(key[0])))
#Line
item = StatTableWidgetItem(str(key[1]))
item.setTextAlignment(Qt.AlignRight)
self.tableWidget.setItem(row, STAT_LINE, item)
#Function name
self.tableWidget.setItem(row, STAT_FUNCTION,
StatTableWidgetItem(str(key[2])))
row += 1
# Store it in stat hash array
self.stat.setStatLink(item, key, TAB_FUNCTIONSTAT)
progress.setValue(row)
if progress.wasCanceled():
return
for i in range(self.tableWidget.rowCount()):
progress.setValue(row + i)
for j in range(self.tableWidget.columnCount()):
item = self.tableWidget.item(i, j)
if item:
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setSortingEnabled(True)
self.resizeWidgetToContent(self.tableWidget)
progress.setValue(2 * rowCount)
def on_tableWidget_itemDoubleClicked(self, item):
matchedItems = []
filename = str(self.tableWidget.item(item.row(), STAT_FILENAME).text())
if not filename or filename.startswith("<"):
# No source code associated, return immediatly
return
function = self.tableWidget.item(item.row(), STAT_FUNCTION).text()
line = self.tableWidget.item(item.row(), STAT_LINE).text()
self.on_tabWidget_currentChanged(TAB_SOURCE) # load source tab
function = "%s (%s)" % (function, line)
fathers = self.sourceTreeWidget.findItems(filename, Qt.MatchContains,
SOURCE_FILENAME)
print(("find %s father" % len(fathers)))
for father in fathers:
findItems(father, function, SOURCE_FILENAME, matchedItems)
print(("find %s items" % len(matchedItems)))
if matchedItems:
self.tabWidget.setCurrentIndex(TAB_SOURCE)
self.sourceTreeWidget.scrollToItem(matchedItems[0])
self.on_sourceTreeWidget_itemClicked(matchedItems[0],
SOURCE_FILENAME)
matchedItems[0].setSelected(True)
else:
print("oups, item found but cannot scroll to it !")
#=======================================================================#
# Source explorer #
#=====================================================================#
def populateSource(self):
items = {}
for stat in self.stat.getStatKeys():
source = stat[0]
function = "%s (%s)" % (stat[2], stat[1])
if source in ("", "profile") or source.startswith("<"):
continue
# Create the function child
child = QTreeWidgetItem([function])
# Store it in stat hash array
self.stat.setStatLink(child, stat, TAB_SOURCE)
if source in items:
father = items[source]
else:
# Create the father
father = QTreeWidgetItem([source])
items[source] = father
father.addChild(child)
self.sourceTreeWidget.setSortingEnabled(False)
for value in list(items.values()):
self.sourceTreeWidget.addTopLevelItem(value)
self.sourceTreeWidget.setSortingEnabled(True)
def on_sourceTreeWidget_itemActivated(self, item, column):
self.on_sourceTreeWidget_itemClicked(item, column)
def on_sourceTreeWidget_itemClicked(self, item, column):
line = 0
parent = item.parent()
if QSCI:
doc = self.sourceTextEdit
if parent:
pathz = parent.text(column)
result = match("(.*) \(([0-9]+)\)", item.text(column))
if result:
try:
function = str(result.group(1))
line = int(result.group(2))
except ValueError:
# We got garbage... falling back to line 0
pass
else:
pathz = item.text(column)
pathz = path.abspath(str(pathz))
if self.currentSourcePath != pathz:
# Need to load source
self.currentSourcePath == pathz
try:
if QSCI:
doc.clear()
doc.insert(file(pathz).read())
else:
self.sourceTextEdit.setPlainText(file(pathz).read())
except IOError:
QMessageBox.warning(self,
"Error", "Source file could not be found",
QMessageBox.Ok)
return
if QSCI:
for function, line in [(i[2], i[1]
) for i in self.stat.getStatKeys() if i[0] == pathz]:
# expr, regexp, case sensitive, whole word, wrap, forward
doc.findFirst("def", False, True, True, False, True, line,
0, True)
end, foo = doc.getCursorPosition()
time = self.stat.getStatTotalTime((pathz, line, function))
colorSource(doc, self.stat.getTotalTime(), time, line, end,
self.marker)
if QSCI:
doc.ensureLineVisible(line)
class WellMarkerDialog(QDialog):
def __init__(self, well):
super(WellMarkerDialog, self).__init__()
self.well = well
self.setupUi()
self.initUI()
self.button_box.accepted.connect(self.save_markers)
self.button_box.rejected.connect(self.close)
self.add_Button.clicked.connect(self.add_row)
self.del_Button.clicked.connect(self.del_row)
self.export_Button.clicked.connect(self.export_markers)
self.import_Button.clicked.connect(self.import_markers)
def setupUi(self):
self.resize(568, 411)
self.setWindowIcon(QIcon(':/icon/layer_icon'))
self.setWindowTitle("Edit Markers")
self.gridLayout = QGridLayout(self)
# table widget
self.tableWidget = QTableWidget(self)
self.tableWidget.setColumnCount(4)
self.tableWidget.setRowCount(0)
self.tableWidget.setHorizontalHeaderItem(0, QTableWidgetItem("Name"))
self.tableWidget.setHorizontalHeaderItem(1,
QTableWidgetItem("TVD (m)"))
self.tableWidget.setHorizontalHeaderItem(2,
QTableWidgetItem("TVDSS (m)"))
self.tableWidget.setHorizontalHeaderItem(3, QTableWidgetItem("Color"))
self.gridLayout.addWidget(self.tableWidget, 0, 0, 1, 1)
# button box
self.button_box = QDialogButtonBox(self)
self.export_Button = self.button_box.addButton(
"Export", QDialogButtonBox.ResetRole)
self.import_Button = self.button_box.addButton(
"Import", QDialogButtonBox.ResetRole)
self.add_Button = self.button_box.addButton("Add",
QDialogButtonBox.ResetRole)
self.del_Button = self.button_box.addButton("Del",
QDialogButtonBox.ResetRole)
self.button_box.setStandardButtons(QDialogButtonBox.Save
| QDialogButtonBox.Cancel)
self.gridLayout.addWidget(self.button_box, 1, 0, 1, 1)
def initUI(self):
self.populate_marker_table()
def populate_marker_table(self):
try:
markers_dict = self.well.params["horizon"]
for mark in markers_dict.keys():
self.tableWidget.insertRow(0)
self.tableWidget.setItem(0, 0, QTableWidgetItem(mark))
self.tableWidget.setItem(
0, 1, QTableWidgetItem(str(markers_dict[mark])))
self.tableWidget.setItem(
0, 2, QTableWidgetItem(str(markers_dict[mark])))
self.tableWidget.sortItems(0, Qt.AscendingOrder)
except KeyError:
pass
def add_row(self):
self.tableWidget.insertRow(self.tableWidget.rowCount())
def del_row(self):
self.tableWidget.removeRow(self.tableWidget.currentRow())
def save_markers(self):
l_names = [str(self.tableWidget.item(irow, 0).text()) \
for irow in range(self.tableWidget.rowCount())]
l_md = [float(self.tableWidget.item(irow, 1).text()) \
for irow in range(self.tableWidget.rowCount())]
new_dict = OrderedDict([(a, b) for a, b in zip(l_names, l_md)])
if self.well.params['horizon'] != new_dict:
respond = QMessageBox.question(
self, "Save Markers", "Sure to save changes?",
QMessageBox.Save | QMessageBox.Cancel)
if respond == QMessageBox.Save:
self.well.params['horizon'] = new_dict
self.well.save_params()
self.close()
def export_markers(self):
file_path = str(QFileDialog.getSaveFileName(self, "Save Markers"))
l_names = [str(self.tableWidget.item(irow, 0).text()) \
for irow in range(self.tableWidget.rowCount())]
l_md = [float(self.tableWidget.item(irow, 1).text()) \
for irow in range(self.tableWidget.rowCount())]
df = pd.DataFrame({"name": l_names, "MD(m)": l_md})
df.to_csv(file_path, sep='\t', columns=["name", "MD(m)"], index=False)
QMessageBox.information(self, "Export Markers", "Succeed!")
def import_markers(self):
read_csv_dialog = ReadCsvDialog()
read_csv_dialog.setWindowIcon(QIcon(':/icon/layer_icon'))
read_csv_dialog.setWindowTitle("Open Markers File")
read_csv_dialog.label.setText("Read Makers from File")
read_csv_dialog.exec_()
class PatternsTable(QWidget):
def __init__(self):
QWidget.__init__(self)
self.grid = QGridLayout()
self.setLayout(self.grid)
self.patternArea()
self.patternTable()
def createPattern(self, name, x):
label = name.lower() + "Label"
type = name.lower() + "Type"
entry = name.lower() + "Entry"
setattr(self, label, QLabel(name))
setattr(self, entry, QLineEdit())
setattr(self, type, QComboBox())
labelobj = getattr(self, label)
typeobj = getattr(self, type)
entryobj = getattr(self, entry)
typeobj.addItem("Hexadecimal")
typeobj.addItem("String")
self.grid.addWidget(labelobj, x, 0)
self.grid.addWidget(entryobj, x, 1)
self.grid.addWidget(typeobj, x, 2)
def patternArea(self):
self.filetypeLabel = QLabel("File type")
self.filetype = QLineEdit()
self.alignedLabel = QLabel("block aligned")
self.aligned = QCheckBox()
self.windowLabel = QLabel("Window size")
self.window = QSpinBox()
self.window.setSuffix(" bytes")
self.window.setRange(0, 2500000)
self.window.setSingleStep(100)
self.addEntry = QPushButton("add")
self.connect(self.addEntry, SIGNAL("clicked()"), self.insertPattern)
self.grid.addWidget(self.filetypeLabel, 0, 0)
self.grid.addWidget(self.filetype, 0, 1, 1, 2)
self.createPattern("Header", 2)
self.createPattern("Footer", 3)
self.grid.addWidget(self.windowLabel, 4, 0)
self.grid.addWidget(self.window, 4, 1)
self.grid.addWidget(self.alignedLabel, 5, 0)
self.grid.addWidget(self.aligned, 5, 1)
self.grid.addWidget(self.addEntry, 6, 1)
def patternTable(self):
self.patterns = QTableWidget()
self.patterns.setShowGrid(False)
self.patterns.setColumnCount(5)
self.patterns.setHorizontalHeaderLabels(["Filetype", "Header", "Footer", "Window", "Block aligned"])
self.patterns.horizontalHeader().setStretchLastSection(True)
self.connect(self.patterns.verticalHeader(), SIGNAL("sectionClicked(int)"), self.patterns.removeRow)
self.grid.addWidget(self.patterns, 7, 0, 1, 3)
def warning(self, msg):
msgBox = QMessageBox(self)
msgBox.setText(msg)
msgBox.setIcon(QMessageBox.Warning)
msgBox.exec_()
def validate(self, **kwargs):
msg = ""
if len(kwargs["type"]) == 0:
msg = "Type must be defined"
else:
for i in kwargs["type"]:
if i not in string.letters:
msg = "Type's characters must be in the following set\n\n" + string.letters
break
rowCount = self.patterns.rowCount()
for row in range(0, rowCount):
if str(self.patterns.item(row, 0).text()) == kwargs["type"]:
msg = "Type <" + kwargs["type"] + " > already defined"
if msg != "":
self.warning(msg)
return False
if kwargs["headerType"] == "Hexadecimal" and not self.isHex(kwargs["header"]):
msg = "Header must be an even number of chars"
self.warning(msg)
return False
if len(kwargs["header"]) == 0:
msg = "Header must be provided"
self.warning(msg)
return False
if kwargs["footerType"] == "Hexadecimal" and not self.isHex(kwargs["footer"]):
msg = "Footer must be an even number of chars"
self.warning(msg)
return False
if kwargs["window"] <= 0:
msg = "Window size must be greater than 0"
self.warning(msg)
return False
return True
def insertPattern(self):
filetype = str(self.filetype.text())
header = str(self.headerEntry.text())
headerType = str(self.headerType.currentText())
footer = str(self.footerEntry.text())
footerType = str(self.footerType.currentText())
window = self.window.text()
aligned = self.aligned.isChecked()
#Validate most of provided items
kwargs = {"type": filetype, "header": header, "headerType": headerType,
"footer": footer, "footerType": footerType, "window": int(window.replace(" bytes", ""))}
if not self.validate(**kwargs):
return
filetypeItem = QTableWidgetItem(filetype)
headerItem = QTableWidgetItem(header + " (" + headerType[0:3] + ")")
footerItem = QTableWidgetItem(footer + " (" + footerType[0:3] + ")")
windowItem = QTableWidgetItem(window)
alignedItem = QTableWidgetItem(str(aligned))
self.patterns.insertRow(self.patterns.rowCount())
vertHeader = QTableWidgetItem(QIcon(":closetab.png"), "")
row = self.patterns.rowCount() - 1
self.patterns.setVerticalHeaderItem(row, vertHeader)
self.patterns.setItem(row, 0, filetypeItem)
self.patterns.setItem(row, 1, headerItem)
self.patterns.setItem(row, 2, footerItem)
self.patterns.setItem(row, 3, windowItem)
self.patterns.setItem(row, 4, alignedItem)
self.patterns.resizeRowToContents(row)
def isHex(self, hstr):
HEXCHAR = "0123456789abcdefABCDEF"
if len(hstr) % 2 != 0:
return False
even = False
for i in range(len(hstr)):
if hstr[i] not in HEXCHAR:
return False
return True
def toHex(self, str):
HEXCHAR = "0123456789abcdefABCDEF"
hexStr = ""
evenhex = ""
for i in range(len(str)):
if str[i] in HEXCHAR:
if len(evenhex) == 1:
hexStr += chr(int(evenhex+str[i], 16))
evenhex = ""
else:
evenhex = str[i]
else:
raise ValueError, "argument 'str' contains not valid characters"
if len(evenhex) != 0:
raise ValueError, "argument 'str' must be an even number of char"
return hexStr
def textToPattern(self, text):
idx = text.find("(")
pattern = ""
if idx != -1:
type = text[idx+1:idx+4]
pattern = text[0:idx-1]
if type == "Hex":
pattern = self.toHex(pattern)
return pattern
def selectedItems(self):
selected = {}
rowCount = self.patterns.rowCount()
for row in range(0, rowCount):
filetype = str(self.patterns.item(row, 0).text())
selected[filetype] = []
pattern = []
pattern.append(self.textToPattern(str(self.patterns.item(row, 1).text())))
pattern.append(self.textToPattern(str(self.patterns.item(row, 2).text())))
pattern.append(int(self.patterns.item(row, 3).text().replace(" bytes", "")))
selected[filetype].append([pattern])
if self.patterns.item(row, 4).text() == "True":
selected[filetype].append(True)
else:
selected[filetype].append(False)
return selected
def view(self):
"""create view and import layers"""
layer = QgsMapLayerRegistry.instance().mapLayer(self.current_layers[0])
uri = QgsDataSourceURI(layer.source())
mtch = re.match(r'(.+)_([^_]+)_rev_(head|\d+)', uri.schema())
schema = mtch.group(1)
assert (schema)
dlg = QDialog()
layout = QVBoxLayout(dlg)
button_box = QDialogButtonBox(dlg)
button_box.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
button_box.accepted.connect(dlg.accept)
button_box.rejected.connect(dlg.reject)
user_msg1 = QgsMessageBar(dlg)
user_msg1.pushInfo(
"Select:", "one [many] for single [multiple] "
"revisions. Fetching may take time.")
pcur = versioning_base.Db(psycopg2.connect(self.pg_conn_info()))
pcur.execute("SELECT rev, commit_msg, branch, date, author "
"FROM " + schema + ".revisions")
revs = pcur.fetchall()
pcur.close()
tblw = QTableWidget(dlg)
tblw.setRowCount(len(revs))
tblw.setColumnCount(6)
tblw.setSortingEnabled(True)
tblw.setHorizontalHeaderLabels([
'Select', 'Revision', 'Commit Message', 'Branch', 'Date', 'Author'
])
tblw.verticalHeader().setVisible(False)
for i, rev in enumerate(revs):
for j, item in enumerate(rev):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
tblw.setItem(i, 0, chkBoxItem)
tblw.setItem(i, j + 1, QTableWidgetItem(str(item)))
layout.addWidget(user_msg1)
layout.addWidget(tblw)
layout.addWidget(button_box)
dlg.resize(650, 300)
if not dlg.exec_():
return
rows = set()
revision_number_list = []
for i in range(len(revs)):
if tblw.item(i, 0).checkState():
print "Revision " + str(i + 1) + " will be fetched"
revision_number_list.append(i + 1)
rows.add(tblw.item(i, 0).row())
progressMessageBar = self.iface.messageBar().createMessage(
"Querying "
"the database for revision(s) " + str(revision_number_list))
progress = QProgressBar()
progress.setMaximum(len(rows))
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar,
self.iface.messageBar().INFO)
progress.setValue(0)
for i, row in enumerate(rows):
progress.setValue(i + 1)
branch = revs[row][2]
rev = revs[row][0]
versioning_base.add_revision_view(uri.connectionInfo(), schema,
branch, rev)
grp_name = branch + ' revision ' + str(rev)
grp_idx = self.iface.legendInterface().addGroup(grp_name)
for layer_id in reversed(self.current_layers):
layer = QgsMapLayerRegistry.instance().mapLayer(layer_id)
new_uri = QgsDataSourceURI(layer.source())
new_uri.setDataSource(
schema + '_' + branch + '_rev_' + str(rev),
new_uri.table(), new_uri.geometryColumn(), new_uri.sql(),
new_uri.keyColumn())
display_name = QgsMapLayerRegistry.instance().mapLayer(
layer_id).name()
src = new_uri.uri().replace('()', '')
new_layer = self.iface.addVectorLayer(src, display_name,
'postgres')
self.iface.legendInterface().moveLayer(new_layer, grp_idx)
self.iface.messageBar().clearWidgets()
class ElemCompDialog(QtGui.QDialog):
def __init__(self,mz, mass,xp,parent=None):
QtGui.QDialog.__init__(self, parent)
settings = QSettings()
size = settings.value("MainWindow/Size",QVariant(QSize(1024,650))).toSize()
self.resize(size)
self.setWindowTitle('Elenmental Composition')
self.xp=xp
self.mass=mass
self.mz=mz
print mz
self.initControls()
# self.initPlots()
def initControls(self):
self.plot1 = Qwt.QwtPlot(self)
self.plot1.setCanvasBackground(Qt.white)
self.plot2 = Qwt.QwtPlot(self)
self.plot2.setCanvasBackground(Qt.white)
self.list = QTreeWidget()
self.list.setColumnCount(11)
self.list.setColumnWidth(0,80)
self.list.setColumnWidth(1,80)
self.list.setColumnWidth(2,60)
self.list.setColumnWidth(3,60)
self.list.setColumnWidth(4,60)
self.list.setColumnWidth(5,150)
self.list.setColumnWidth(7,30)
self.list.setColumnWidth(8,30)
self.list.setColumnWidth(9,30)
self.list.setColumnWidth(10,30)
self.list.setHeaderLabels(['Mass','Calc.Mass','mDa','PPM','DBE','Formula','Fit Conf %','C','H','N','O'])
self.list.setSortingEnabled(True)
self.table = QTableWidget(1,11)
self.table.setColumnWidth(0,80)
self.table.setColumnWidth(1,80)
self.table.setColumnWidth(2,60)
self.table.setColumnWidth(3,60)
self.table.setColumnWidth(4,60)
self.table.setColumnWidth(5,150)
self.table.setColumnWidth(7,30)
self.table.setColumnWidth(8,30)
self.table.setColumnWidth(9,30)
self.table.setColumnWidth(10,30)
self.table.setHorizontalHeaderLabels(['Mass','Calc.Mass','mDa','PPM','DBE','Formula','Fit Conf %','C','H','N','O'])
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
self.table.setSelectionMode(QTableWidget.SingleSelection)
self.table.setAlternatingRowColors(True)
print self.connect(self.table, SIGNAL("itemActivated(QTableWidgetItem*)"), self.tableClicked)
# self.connect(self.library_list, SIGNAL("itemSelectionChanged()"), self.libraryListClicked)
up_hbox=QVBoxLayout()
up_hbox.addWidget(self.table)
down_hbox = QVBoxLayout()
down_hbox.addWidget(self.plot1)
down_hbox.addWidget(self.plot2)
hbox = QVBoxLayout()
hbox.addLayout(up_hbox, 3.5)
hbox.addLayout(down_hbox, 3.5)
self.setLayout(hbox)
self.cal_mass()
def tableClicked(self,item):
self.C=self.table.item(item.row(),7).text()
self.H=self.table.item(item.row(),8).text()
self.N=self.table.item(item.row(),9).text()
self.O=self.table.item(item.row(),10).text()
self.cal_isotopic()
self.initPlots()
def initPlots(self):
self.plot1.clear()
# self.plot1.setTitle("Observed Isotope Distribution")
# self.plot1.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)')
# self.plot1.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity')
# grid = Qwt.QwtPlotGrid()
pen = QPen(Qt.DotLine)
pen.setColor(Qt.black)
pen.setWidth(0)
# grid.setPen(pen)
# grid.attach(self.plot1)
self.mass1=self.mass/self.massy*100
self.plot1.setAxisScale(self.plot1.xBottom,self.x_min,self.x_max)
self.plot1.setAxisScale(self.plot1.yLeft,0,1.1*100)
color = QColor('black')
curve = Qwt.QwtPlotCurve("test1")
pen = QPen(color)
pen.setWidth(1)
curve.setPen(pen)
curve.setData(self.mass_x,self.mass_y)
curve.setStyle(Qwt.QwtPlotCurve.Sticks)
curve.attach(self.plot1)
self.plot1.replot()
self.plot2.clear()
# self.plot2.setTitle("Theoretical Isotope Distribution")
# self.plot2.setAxisTitle(Qwt.QwtPlot.xBottom, 'Raman shift (cm-1)')
# self.plot2.setAxisTitle(Qwt.QwtPlot.yLeft, 'Intensity')
# grid = Qwt.QwtPlotGrid()
pen = QPen(Qt.DotLine)
pen.setColor(Qt.blue)
self.plot2.setAxisScale(self.plot1.xBottom,self.x_min,self.x_max)
self.plot2.setAxisScale(self.plot1.yLeft,0,1.1*100)
color = QColor('blue')
curve = Qwt.QwtPlotCurve("test1")
pen = QPen(color)
pen.setWidth(1)
curve.setPen(pen)
# self.axis= np.arange(len(self.mass))
curve.setData(self.x,self.y)
curve.setStyle(Qwt.QwtPlotCurve.Sticks)
curve.attach(self.plot2)
pen.setWidth(0)
# grid.setPen(pen)
# grid.attach(self.plot2)
self.plot2.replot()
def cal_mass(self):
# charge=0.0
tol = 10.0
# electron=0.000549
measured_mass=np.round(self.xp)
limit_lo = measured_mass - (tol/1000.0)
limit_hi = measured_mass + (tol/1000.0)
mass=[]
mass.append((12.000000000,2.0,"C"))
#mass.append((78.9183376,-1.0,"Br"))
#mass.append((34.96885271,-1.0,"Cl"))
#mass.append((31.97207069,0.0,"S"))
#mass.append((30.97376151,1.0,"P"))
#mass.append((27.9769265327,2.0,"Si"))
#mass.append((22.98976967,-1.0,"Na"))
#mass.append((18.99840320,-1.0,"F"))
mass.append((15.9949146221,0.0,"O"))
mass.append((14.0030740052,1.0,"N"))
mass.append((1.0078250321,-1.0,"H"))
print range(1,10)
print mass[0][0]
print mass[1][0]
print mass[2][0]
calc_mass=[]
for i in range(1,int(floor(measured_mass/mass[0][0]))+1):
for j in range(0,int(floor((measured_mass-mass[0][0]*i)/mass[1][0]))+1):
for k in range(0,int(floor((measured_mass-mass[0][0]*i-mass[1][0]*j)/mass[2][0]))+1):
# rr=(measured_mass-mass[0][0]*i-mass[1][0]*j-mass[2][0]*k)/mass[3][0]
# rrr=round((measured_mass-mass[0][0]*i-mass[1][0]*j-mass[2][0]*k)/mass[3][0])
# rrrr=int(round((measured_mass-mass[0][0]*i-mass[1][0]*j-mass[2][0]*k)/mass[3][0]))
# print "rr:%s"%rr+" rrr:%s"%rrr+" rrrr:%s"%rrrr
r=int(round((measured_mass-mass[0][0]*i-mass[1][0]*j-mass[2][0]*k)/mass[3][0]))
calmass=mass[0][0]*i+mass[1][0]*j+mass[2][0]*k+mass[3][0]*r
if (mass[0][1]*i+mass[2][1]*k+mass[3][1]*r)>=-1 and calmass>limit_lo and calmass<limit_hi:
calc_mass.append((calmass,i,j,k,r))
print len(calc_mass)
for ii in range(0,len(calc_mass)):
mda=(measured_mass-calc_mass[ii][0])*1000
ppm=(measured_mass-calc_mass[ii][0])/measured_mass*1000000
DBE=(calc_mass[ii][1]*2+calc_mass[ii][3]-calc_mass[ii][4]+2)/2.0
self.calmass="%.4f"%calc_mass[ii][0]
self.mda="%.1f"%mda
self.ppm="%.1f"%ppm
self.DBE="%.1f"%DBE
self.C="%s"%calc_mass[ii][1]
self.H="%s"%calc_mass[ii][4]
self.N="%s"%calc_mass[ii][3]
self.O="%s"%calc_mass[ii][2]
self.Formula="C%2s"%self.C+" H%2s"%self.H+" N%2s"%self.N+" O%2s"%self.O
mass=str(self.xp)
# if not(ii==0):
# mass=""
self.cal_isotopic()
self.initPlots()
self.conf="%.1f"%self.mass_diff
self.table.insertRow(ii)
self.table.setRowHeight(ii,20)
self.table.setItem(ii, 0,QTableWidgetItem(mass))
self.table.setItem(ii, 1,QTableWidgetItem(self.calmass))
self.table.setItem(ii, 2,QTableWidgetItem(self.mda))
self.table.setItem(ii, 3,QTableWidgetItem(self.ppm))
self.table.setItem(ii, 4,QTableWidgetItem(self.DBE))
self.table.setItem(ii, 5,QTableWidgetItem(self.Formula))
self.table.setItem(ii, 6,QTableWidgetItem(self.conf))
self.table.setItem(ii, 7,QTableWidgetItem(self.C))
self.table.setItem(ii, 8,QTableWidgetItem(self.H))
self.table.setItem(ii, 9,QTableWidgetItem(self.N))
self.table.setItem(ii, 10,QTableWidgetItem(self.O))
item=QTreeWidgetItem([mass,str(self.calmass),str(self.mda),str(self.ppm),str(self.DBE),self.Formula,str(self.conf),str(self.C),str(self.H),str(self.N),str(self.O)])
self.list.addTopLevelItem(item)
self.table.removeRow(len(calc_mass))
self.table.setSortingEnabled(True)
# self.table.sortByColumn(1,Qt.DescendingOrder)
def next2pow(self):
return 2**int(np.ceil(np.log(float(self.xx))/np.log(2.0)))
def cal_isotopic(self):
MAX_ELEMENTS=5+1 # add 1 due to mass correction 'element'
MAX_ISOTOPES=4 # maxiumum # of isotopes for one element
CUTOFF=1e-4 # relative intensity cutoff for plotting
WINDOW_SIZE = 500
#WINDOW_SIZE=input('Window size (in Da) ---> ');
#RESOLUTION=input('Resolution (in Da) ----> '); % mass unit used in vectors
RESOLUTION = 1
if RESOLUTION < 0.00001:# % minimal mass step allowed
RESOLUTION = 0.00001
elif RESOLUTION > 0.5: # maximal mass step allowed
RESOLUTION = 0.5
R=0.00001/RESOLUTION# % R is used to scale nuclide masses (see below)
WINDOW_SIZE=WINDOW_SIZE/RESOLUTION;
self.xx=WINDOW_SIZE # convert window size to new mass units
WINDOW_SIZE=self.next2pow(); # fast radix-2 fast-Fourier transform algorithm
if WINDOW_SIZE < np.round(496708*R)+1:
WINDOW_SIZE = self.next2pow(np.round(496708*R)+1) # just to make sure window is big enough
#H378 C254 N65 O75 S6
M=np.array([int(self.H),int(self.C),int(self.N),int(self.O),0,0]) #% empiric formula, e.g. bovine insulin
# isotopic abundances stored in matrix A (one row for each element)
A=np.zeros((MAX_ELEMENTS,MAX_ISOTOPES,2));
A[0][0,:] = [100783,0.9998443]# % 1H
A[0][1,:] = [201410,0.0001557]# % 2H
A[1][0,:] = [100000,0.98889]# % 12C
A[1][1,:] = [200336,0.01111]# % 13C
A[2][0,:] = [100307,0.99634]# % 14N
A[2][1,:] = [200011,0.00366]# % 15N
A[3][0,:] = [99492,0.997628]# % 16O
A[3][1,:] = [199913,0.000372]# % 17O
A[3][2,:] = [299916,0.002000]# % 18O
A[4][0,:] = [97207,0.95018]# % 32S
A[4][1,:] = [197146,0.00750]# % 33S
A[4][2,:] = [296787,0.04215]# % 34S
A[4][3,:] = [496708,0.00017]# % 36S
A[5][0,:] = [100000,1.00000]# % for shifting mass so that Mmi is
# % near left limit of window
Mmi=np.array([np.round(100783*R), np.round(100000*R),\
np.round(100307*R),np.round(99492*R), np.round(97207*R), 0])*M# % (Virtual) monoisotopic mass in new units
Mmi = Mmi.sum()
#% mass shift so Mmi is in left limit of window:
FOLDED=np.floor(Mmi/(WINDOW_SIZE-1))+1# % folded FOLDED times (always one folding due to shift below)
#% shift distribution to 1 Da from lower window limit:
M[MAX_ELEMENTS-1]=np.ceil(((WINDOW_SIZE-1)-np.mod(Mmi,WINDOW_SIZE-1)+np.round(100000*R))*RESOLUTION)
MASS_REMOVED=np.array([0,11,13,15,31,-1])*M#% correction for 'virtual' elements and mass shift
begin=WINDOW_SIZE*RESOLUTION+MASS_REMOVED.sum()
end=2*(WINDOW_SIZE-1)*RESOLUTION+MASS_REMOVED.sum()
ptA=np.ones(WINDOW_SIZE);
t_fft=0
t_mult=0
for i in xrange(MAX_ELEMENTS):
tA=np.zeros(WINDOW_SIZE)
for j in xrange(MAX_ISOTOPES):
if A[i][j,0] != 0:
#removed +1 after R)+1 --we're using python
tA[np.round(A[i][j,0]*R)]=A[i][j,1]#; % put isotopic distribution in tA
t0 = time.clock()
tA=F.fft(tA) # FFT along elements isotopic distribution O(nlogn)
t_fft = time.clock()-t0
t0 = time.clock()
tA=tA**M[i]# % O(n)
#################
ptA = ptA*tA# % O(n)#this is where it is messing UP
#################
t1 = time.clock()
t_mult=t1-t0
t0=time.clock()
ptA=F.ifft(ptA).real#; % O(nlogn)
t0=time.clock()
MA=np.linspace(begin,end,WINDOW_SIZE-1)
ind=np.where(ptA>CUTOFF)[0]
self.x = MA[ind]
self.y = ptA[ind]
self.x_min=int(np.min(self.x)-(np.max(self.x)-np.min(self.x)))
self.x_max=int(np.min(self.x)+(np.max(self.x)-np.min(self.x)))
self.mass_y=np.ones(len(self.x))
mass_diff=np.ones(len(self.x))
mzInd= np.logical_and((self.mz>=self.x_min),(self.mz<=self.x_max))
self.mass_y=self.mass[mzInd]
self.mass_x=self.mz[mzInd]
# for i in range(len(self.x)):
# self.mass_y[i]=self.mass[int(self.x[i])]
self.massy=np.max(self.mass_y)
print self.massy
self.mass_y=self.mass_y/max(self.mass_y)*100
self.y=self.y/max(self.y)*100
# k=(self.mass_y*self.y).sum()/(self.mass_y*self.mass_y).sum()
# self.fit=((k*self.mass_y-self.y)*(k*self.mass_y-self.y)).sum()/(self.y*self.y).sum()
for i in range(len(self.y)):
mass_diff[i]=np.abs(self.mass_y[i]-self.y[i])/(self.mass_y[i]+self.y[i])
self.mass_diff=(1-mass_diff.sum()/len(mass_diff))*100
class GraphDialog(QDialog):
edit_patterns = 0
edit_curves = 1
titles = {edit_patterns: 'Pattern editor', edit_curves: 'Curve editor'}
labels = {edit_patterns: 'Patterns', edit_curves: 'Curves'}
def __init__(self, dockwidget, parent, params, edit_type):
QDialog.__init__(self, parent)
main_lay = QVBoxLayout(self)
self.dockwidget = dockwidget
self.params = params
self.edit_type = edit_type
self.x_label = ''
self.y_label = ''
self.setMinimumWidth(600)
self.setMinimumHeight(400)
self.setWindowTitle(self.titles[edit_type]) # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.current = None
self.current_saved = False
# File
self.lbl_file = QLabel('File:')
self.fra_file = QFrame()
self.fra_file.setContentsMargins(0, 0, 0, 0)
fra_file_lay = QHBoxLayout(self.fra_file)
if edit_type == self.edit_patterns:
self.txt_file = QLineEdit(self.params.patterns_file)
elif edit_type == self.edit_curves:
self.txt_file = QLineEdit(self.params.curves_file)
self.txt_file.setReadOnly(True)
self.txt_file.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignVCenter)
self.txt_file.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
fra_file_lay.addWidget(self.txt_file)
self.btn_file = QPushButton('Change') # TODO: softcode
self.btn_file.clicked.connect(self.import_file)
fra_file_lay.addWidget(self.btn_file)
fra_file_lay.setContentsMargins(0, 0, 0, 0)
self.lbl_list = QLabel(self.labels[edit_type])
self.lst_list = QListWidget()
self.lst_list.currentItemChanged.connect(self.list_item_changed)
# Form
self.fra_form = QFrame()
fra_form1_lay = QFormLayout(self.fra_form)
fra_form1_lay.setContentsMargins(0, 0, 0, 0)
fra_form1_lay.addRow(self.lbl_list, self.lst_list)
# Buttons
self.fra_buttons = QFrame()
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
fra_buttons_lay.setContentsMargins(0, 0, 0, 0)
if self.edit_type == self.edit_patterns:
ele_name = 'pattern'
elif self.edit_type == self.edit_curves:
ele_name = 'curve'
self.btn_new = QPushButton('New ' + ele_name) # TODO: softcode
self.btn_new.clicked.connect(self.new_element)
fra_buttons_lay.addWidget(self.btn_new)
self.btn_import = QPushButton('Import ' + ele_name +
's') # TODO: softcode
self.btn_import.clicked.connect(self.import_file)
fra_buttons_lay.addWidget(self.btn_import)
self.btn_save = QPushButton('Save current ' +
ele_name) # TODO: softcode
self.btn_save.clicked.connect(self.save)
fra_buttons_lay.addWidget(self.btn_save)
self.btn_del = QPushButton('Delete current ' +
ele_name) # TODO: softcode
self.btn_del.clicked.connect(self.del_item)
fra_buttons_lay.addWidget(self.btn_del)
# ID
self.lbl_id = QLabel('ID:')
self.txt_id = QLineEdit()
self.txt_id.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.MinimumExpanding)
self.lbl_desc = QLabel('Desc.:')
self.txt_desc = QLineEdit()
self.fra_id = QFrame()
fra_id_lay = QHBoxLayout(self.fra_id)
fra_id_lay.addWidget(self.lbl_id)
fra_id_lay.addWidget(self.txt_id)
fra_id_lay.addWidget(self.lbl_desc)
fra_id_lay.addWidget(self.txt_desc)
# Table form
self.table = QTableWidget(self)
self.rows_nr = 24
self.cols_nr = 2
self.table.setRowCount(self.rows_nr)
self.table.setColumnCount(self.cols_nr)
self.table.verticalHeader().setVisible(False)
# Initialize empty table
self.clear_table()
self.table.itemChanged.connect(self.data_changed)
self.fra_table = QFrame()
fra_table_lay = QVBoxLayout(self.fra_table)
fra_table_lay.setContentsMargins(0, 0, 0, 0)
if edit_type == self.edit_curves:
self.fra_pump_type = QFrame()
fra_pump_type_lay = QFormLayout(self.fra_pump_type)
self.lbl_pump_type = QLabel('Curve type:') # TODO: softcode
self.cbo_pump_type = QComboBox()
for key, name in Curve.type_names.iteritems():
self.cbo_pump_type.addItem(name, key)
fra_pump_type_lay.addRow(self.lbl_pump_type, self.cbo_pump_type)
fra_table_lay.addWidget(self.fra_pump_type)
self.cbo_pump_type.activated.connect(self.cbo_pump_type_activated)
fra_table_lay.addWidget(self.table)
self.btn_add_row = QPushButton('Add row')
self.btn_add_row.clicked.connect(self.add_row)
fra_table_lay.addWidget(self.btn_add_row)
# Graph canvas
self.fra_graph = QFrame()
self.static_canvas = StaticMplCanvas(self.fra_graph,
width=5,
height=4,
dpi=100)
fra_graph_lay = QVBoxLayout(self.fra_graph)
fra_graph_lay.addWidget(self.static_canvas)
# Top frame
self.fra_top = QFrame()
fra_top_lay = QVBoxLayout(self.fra_top)
fra_top_lay.addWidget(self.fra_form)
fra_top_lay.addWidget(self.fra_id)
fra_top_lay.addWidget(self.fra_buttons)
# Bottom frame
self.fra_bottom = QFrame()
fra_bottom_lay = QHBoxLayout(self.fra_bottom)
fra_bottom_lay.addWidget(self.fra_table)
fra_bottom_lay.addWidget(self.fra_graph)
# Main
main_lay.addWidget(self.fra_top)
main_lay.addWidget(self.fra_bottom)
# Get existing patterns/curves
self.need_to_update_graph = False
if self.edit_type == self.edit_patterns:
for pattern_id, pattern in self.params.patterns.iteritems():
self.lst_list.addItem(pattern.id)
elif self.edit_type == self.edit_curves:
for curve_id, curve in self.params.curves.iteritems():
self.lst_list.addItem(curve.id)
if self.lst_list.count() > 0:
self.lst_list.setCurrentRow(0)
self.txt_id.setEnabled(True)
self.txt_desc.setEnabled(True)
self.btn_save.setEnabled(True)
self.btn_del.setEnabled(True)
self.table.setEnabled(True)
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
else:
self.txt_id.setEnabled(False)
self.txt_desc.setEnabled(False)
self.btn_save.setEnabled(False)
self.btn_del.setEnabled(False)
self.table.setEnabled(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.new_dialog = None
self.need_to_update_graph = True
def cbo_pump_type_activated(self):
self.update_table_headers()
self.update_graph()
def add_row(self):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
col = 0
item = QTableWidgetItem(str(row_pos))
if self.edit_type == self.edit_patterns:
self.table.setItem(row_pos, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
def setVisible(self, bool):
QDialog.setVisible(self, bool)
self.update_table_headers()
self.update_graph()
def list_item_changed(self):
p_index = self.lst_list.currentRow()
flags = Qt.ItemFlags()
flags != Qt.ItemIsEnabled
# Clear table
self.clear_table()
self.need_to_update_graph = False
if p_index >= 0:
self.table.setRowCount(0)
if self.edit_type == self.edit_patterns:
self.current = self.params.patterns[
self.lst_list.currentItem().text()]
for v in range(len(self.current.values)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
item = QTableWidgetItem(str(v))
item.setFlags(flags)
self.table.setItem(v, 0, item)
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.values[v])))
elif self.edit_type == self.edit_curves:
self.current = self.params.curves[
self.lst_list.currentItem().text()]
for v in range(len(self.current.xs)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
self.table.setItem(
v, 0, QTableWidgetItem(str(self.current.xs[v])))
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.ys[v])))
curve_type = self.current.type
self.cbo_pump_type.setCurrentIndex(curve_type)
# Update GUI
self.txt_id.setText(self.current.id)
self.txt_desc.setText(self.current.desc)
self.update_table_headers()
# Update graph
self.need_to_update_graph = True
self.update_graph()
else:
# No curves
self.txt_id.setText('')
self.txt_desc.setText('')
# Update table and chart
self.need_to_update_graph = False
for v in range(self.table.columnCount()):
self.table.setItem(v, 1, QTableWidgetItem(''))
self.need_to_update_graph = True
self.update_graph()
def import_file(self):
config_file = ConfigFile(Parameters.config_file_path)
directory = None
if self.edit_type == GraphDialog.edit_curves:
directory = self.params.last_curves_dir
elif self.edit_type == GraphDialog.edit_patterns:
directory = self.params.last_patterns_dir
if directory is None:
directory = self.params.last_project_dir
file_path = QFileDialog.getOpenFileName(self, 'Select file', directory,
'Files (*.txt *.inp)')
if file_path is None or file_path == '':
return
else:
if self.edit_type == GraphDialog.edit_patterns:
# Save patterns file path in configuration file
config_file.set_patterns_file_path(file_path)
Parameters.patterns_file = file_path
elif self.edit_type == GraphDialog.edit_curves:
# Save curve file path in configuration file
config_file.set_curves_file_path(file_path)
Parameters.curves_file = file_path
self.read(file_path)
def read(self, file_path):
self.lst_list.clear()
if self.edit_type == self.edit_patterns:
InpFile.read_patterns(self.params, file_path)
for pattern_id, pattern in self.params.patterns.iteritems():
# desc = ' (' + pattern.desc + ')' if pattern.desc is not None else ''
self.lst_list.addItem(pattern.id)
self.params.patterns[pattern.id] = pattern
elif self.edit_type == self.edit_curves:
InpFile.read_curves(self.params, file_path)
for curve_id, curve in self.params.curves.iteritems():
# desc = ' (' + curve.desc + ')' if curve.desc is not None else ''
self.lst_list.addItem(curve.id)
self.params.curves[curve.id] = curve
if self.lst_list.count() > 0:
self.lst_list.setCurrentRow(0)
def new_element(self):
old_ids = []
if self.edit_type == self.edit_patterns:
for pattern in self.params.patterns.itervalues():
old_ids.append(pattern.id)
elif self.edit_type == self.edit_curves:
for curve in self.params.curves.itervalues():
old_ids.append(curve.id)
self.new_dialog = NewIdDialog(self, old_ids)
self.new_dialog.exec_()
new_id = self.new_dialog.get_newid()
description = self.new_dialog.get_description()
if new_id is None or description is None:
return
if self.edit_type == self.edit_patterns:
new_pattern = Pattern(new_id, description)
self.params.patterns[new_pattern.id] = new_pattern
self.lst_list.addItem(new_pattern.id)
elif self.edit_type == self.edit_curves:
curve_type = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
new_curve = Curve(new_id, curve_type, desc=description)
self.params.curves[new_curve.id] = new_curve
self.lst_list.addItem(new_curve.id)
self.lst_list.setCurrentRow(self.lst_list.count() - 1)
self.txt_id.setText(new_id)
self.txt_desc.setText(description)
# Clear table
self.clear_table()
self.static_canvas.axes.clear()
self.txt_id.setEnabled(True)
self.txt_desc.setEnabled(True)
self.btn_save.setEnabled(True)
self.btn_del.setEnabled(True)
self.table.setEnabled(True)
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
def save(self):
self.need_to_update_graph = False
# Check for ID
if not self.txt_id.text():
QMessageBox.warning(
self,
Parameters.plug_in_name,
u'Please specify the ID.', # TODO: softcode
QMessageBox.Ok)
return
if self.edit_type == GraphDialog.edit_patterns:
values = []
for row in range(self.table.rowCount()):
item = self.table.item(row, 1)
if item is not None and item.text() != '':
values.append(self.from_item_to_val(item))
else:
values.append('0')
pattern = Pattern(self.txt_id.text(), self.txt_desc.text(), values)
old_patterns = self.params.patterns
old_patterns[pattern.id] = pattern
self.params.patterns = old_patterns
self.lst_list.currentItem().setText(pattern.id)
elif self.edit_type == GraphDialog.edit_curves:
# Check for ID unique
xs = []
ys = []
for row in range(self.table.rowCount()):
item_x = self.table.item(row, 0)
item_y = self.table.item(row, 1)
if item_x.text() != '' and item_y.text() != '':
xs.append(self.from_item_to_val(item_x))
ys.append(self.from_item_to_val(item_y))
curve_type = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
curve = Curve(self.txt_id.text(), curve_type, self.txt_desc.text())
for v in range(len(xs)):
curve.append_xy(xs[v], ys[v])
old_curves = self.params.curves
old_curves[curve.id] = curve
self.params.curves = old_curves
self.lst_list.currentItem().setText(curve.id)
# Update GUI
self.dockwidget.update_curves_combo()
# self.read()
self.need_to_update_graph = True
def clear_table(self):
self.need_to_update_graph = False
for r in range(self.table.rowCount()):
self.table.setItem(r, 0, QTableWidgetItem(None))
self.table.setItem(r, 1, QTableWidgetItem(None))
for row in range(self.rows_nr):
for col in range(self.cols_nr):
if self.edit_type == self.edit_patterns:
if col == 0:
item = QTableWidgetItem(str(row))
self.table.setItem(row, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
# elif col == 1 and row == 0:
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, col, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
# elif self.edit_type == self.edit_curves:
# if row == 0:
# item = QTableWidgetItem(str(0))
# self.table.setItem(row, 0, item)
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, 1, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.need_to_update_graph = True
def del_item(self):
selected_row = self.lst_list.currentRow()
name = self.lst_list.currentItem().text()
if selected_row < 0:
return
self.lst_list.takeItem(selected_row)
if self.lst_list.count() == 0:
self.txt_id.setEnabled(False)
self.txt_desc.setEnabled(False)
self.btn_save.setEnabled(False)
self.btn_del.setEnabled(False)
self.table.setEnabled(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
if self.edit_type == GraphDialog.edit_curves:
del self.params.curves[name]
# Update GUI
self.dockwidget.update_curves_combo()
elif self.edit_type == GraphDialog.edit_patterns:
del self.params.patterns[name]
# Update GUI
self.dockwidget.update_patterns_combo()
def data_changed(self):
if self.need_to_update_graph:
self.update_graph()
def update_table_headers(self):
if self.edit_type == self.edit_patterns:
self.x_label = 'Time period'
self.y_label = 'Multiplier'
elif self.edit_type == self.edit_curves:
cbo_data = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
if cbo_data == Curve.type_efficiency:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Efficiency ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_headloss:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Headloss ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_pump:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Head ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_volume:
self.x_label = 'Height ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Volume ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
self.table.setHorizontalHeaderLabels([self.x_label,
self.y_label]) # TODO: softcode
def update_graph(self):
if not self.need_to_update_graph:
return
xs = []
ys = []
for row in range(self.table.rowCount()):
item = self.table.item(row, 0)
x = self.from_item_to_val(item)
item = self.table.item(row, 1)
y = self.from_item_to_val(item)
if x is not None:
xs.append(float(x))
if y is not None:
ys.append(float(y))
if len(xs) == 0 or len(ys) == 0:
self.static_canvas.clear()
return
xys_t = zip(xs, ys)
xys_t.sort()
xys = zip(*xys_t)
xs = xys[0]
ys = xys[1]
if self.edit_type == self.edit_patterns:
y_axis_label = 'Mult. avg.: ' + '{0:.2f}'.format(
(numpy.average(ys)))
self.static_canvas.draw_bars_graph(
ys,
time_period=self.params.times.pattern_timestep,
y_axes_label=y_axis_label)
elif self.edit_type == self.edit_curves:
# Account for different types of curves
cbo_data = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
series_length = min(len(xs), len(ys))
# Need to account for different types of curves
if cbo_data == Curve.type_efficiency or cbo_data == Curve.type_headloss or cbo_data == Curve.type_volume:
self.static_canvas.draw_line_graph(xs[:series_length],
ys[:series_length],
self.x_label, self.y_label)
elif cbo_data == Curve.type_pump:
if series_length == 1 or series_length == 3:
if series_length == 1:
# 3 curve points
curve_xs = [0, xs[0], xs[0] * 2]
curve_ys = [ys[0] * 1.33, ys[0], 0]
# y = a * x^2 + b * x + c
elif series_length == 3:
# 3 curve points
curve_xs = [xs[0], xs[1], xs[2]]
curve_ys = [ys[0], ys[1], ys[2]]
(a, b, c) = numpy.polyfit(curve_xs, curve_ys, 2)
# Create a few interpolated values
interp_xs = []
interp_ys = []
n_vals = 30
for v in range(n_vals + 1):
x = (curve_xs[2] - curve_xs[0]) / n_vals * v
interp_xs.append(x)
y = a * x**2 + b * x + c
interp_ys.append(y)
self.static_canvas.draw_line_graph(interp_xs, interp_ys,
self.x_label,
self.y_label)
else:
self.static_canvas.draw_line_graph(xs[:series_length],
ys[:series_length],
self.x_label,
self.y_label)
def from_item_to_val(self, item):
if item is None:
value = None
else:
value = item.text()
try:
value = float(value)
value = max(value, 0)
except:
value = None
return value
class edycja_proby(QDialog):
def __init__(self, sample, defpol={}, defpol_order=[], parent=None):
''' defpol and defpol_order should contains the same values, it will
not be checked in this class is it valid, pay attention to it'''
super(edycja_proby, self).__init__(parent)
# self.dane = globals()["daneW"][0]
# self.defpol = globals()["daneW"][1]
# globals()["daneW"] = []
self.sample = copy.deepcopy(sample)
self.sample._edytowany = 'E'
self.org_sample = sample
self.newName = self.sample.KeyCode()
self.setWindowTitle("Sample: " + self.sample.KeyCode())
self.resize(691, 749)
self.setMinimumSize(QSize(691, 749))
# self.setMaximumSize(QSize(691, 749))
# Prepare headers
self.defpol = defpol
self.defpol_order = defpol_order
self.prepareDefPol()
self.selected = [] # list with index of selected ring in sample
# ustawienie pol z danymi
self.p_naglowek = QTableWidget()
self.p_naglowek.setObjectName("p_naglowek")
self.p_naglowek.setColumnCount(1)
self.p_naglowek.setRowCount(len(self.headers))
self.p_naglowek.setHorizontalHeaderLabels(["Value"])
self.p_naglowek.setVerticalHeaderLabels(self.headers)
self.p_naglowek.setAlternatingRowColors(True)
self.p_naglowek.setSortingEnabled(False)
self.p_dane = QTableWidget()
self.p_dane.setObjectName("p_dane")
self.p_dane.setColumnCount(10)
self.p_dane.setHorizontalHeaderLabels(
["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"])
self.dodaj = QPushButton("Add")
self.usun = QPushButton("Delete")
self.przerysuj = QPushButton("Redraw")
self.podziel = QPushButton("Divide")
self.polacz = QPushButton("Join")
self.anuluj = QPushButton("Cancel")
self.wykonaj = QPushButton("Update")
self.vbl = QVBoxLayout()
self.qmc = Qt4MplCanvas(self)
self.ntb = NavigationToolbar(self.qmc, self)
self.vbl.addWidget(self.qmc)
self.vbl.addWidget(self.ntb)
self.updateHeaderTable()
self.wpisz_pomiary()
self.przerysuj_wykres()
# ustawiamy wyglad okna
layout = QGridLayout()
layout.addWidget(self.p_naglowek, 0, 0)
layout1 = QGridLayout()
layout1.addWidget(self.p_dane, 0, 0, 1, 5)
layout1.addWidget(self.dodaj, 1, 0)
layout1.addWidget(self.usun, 1, 1)
layout1.addWidget(self.podziel, 1, 2)
layout1.addWidget(self.polacz, 1, 3)
layout1.addWidget(self.przerysuj, 1, 4)
layout1.setRowMinimumHeight(1, 25)
layout1.setRowStretch(0, 1)
layout.addLayout(layout1, 0, 1)
layout.addLayout(self.vbl, 1, 0, 1, 2)
layout.addWidget(self.anuluj, 2, 0)
layout.addWidget(self.wykonaj, 2, 1)
layout.setColumnMinimumWidth(0, 290)
layout.setColumnStretch(1, 1)
layout.setRowStretch(0, 1)
layout.setRowMinimumHeight(0, 350)
self.setLayout(layout)
# Sygnaly
self.connect(self.anuluj, SIGNAL("clicked()"), self.schowaj)
self.connect(self.wykonaj, SIGNAL("clicked()"), self.wykonaj_odczytanie)
self.connect(self.dodaj, SIGNAL("clicked()"), self.dodaj_wartosc)
self.connect(self.przerysuj, SIGNAL("clicked()"), self.przerysuj_wykres)
self.connect(self.usun, SIGNAL("clicked()"), self.usun_wartosc)
self.connect(self.podziel, SIGNAL("clicked()"), self.podziel_wartosc)
self.connect(self.polacz, SIGNAL("clicked()"), self.polacz_wartosc)
self.p_naglowek.cellChanged.connect(self.edytowana_kom_nagl)
self.p_dane.itemSelectionChanged.connect(self.przerysuj_wykres)
self.p_dane.cellChanged.connect(self.przerysuj_wykres)
def prepareDefPol(self):
"""Prepare Headers for metadata,
BEAWARE! measurements are delete on the end"""
self.headers = [
'KeyCode',
'DateBegin',
'DateEnd',
'Length',
'Gat',
'SapWoodRings',
'measurements',
]
add_table = []
if len(self.defpol_order):
add_table = self.defpol_order[:]
elif len(self.defpol.keys()):
add_table = sorted(list(self.defpol.keys()))
else:
add_table = sorted(self.sample.unikalneNaglowki())
for val in add_table:
if val not in self.headers:
self.headers.append(val)
self.headers.remove('measurements')
def updateHeaderTable(self):
# Dodaj wartosci wierszow dla tabeli naglowka proby
self.p_naglowek.blockSignals(True)
for i, val in enumerate(self.headers):
if self.sample.wypiszMetadana(val):
komorka = QTableWidgetItem(str(self.sample.wypiszMetadana(val)))
else:
komorka = QTableWidgetItem('---')
if val == 'Length':
komorka.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.p_naglowek.setItem(i, 0, komorka)
self.p_naglowek.blockSignals(False)
def wykonaj_odczytanie(self):
# spisz cala probe z edytowanych tabel i zapisz ja do zmiennej globalnej
# daneW
self.odczytaj_dane(origin='org')
self.newName = self.org_sample.KeyCode()
self.hide()
def przerysuj_wykres(self):
self.odczytaj_dane()
self.updateHeaderTable()
self.chartData = [
[], # X axis - years
[], # Y axis - measurements
]
self.chartData[1] = self.sample.wypiszPomiary()
self.chartData[0] = range(1, self.sample.Length() + 1)
self.qmc.axes.clear()
# draw sample curve
self.qmc.axes.plot(self.chartData[0], self.chartData[1])
# draw selected years
Xpoints = []
Ypoints = []
self.selected = []
j = 0
for i in range(self.sample.Length()):
if i == 11:
j += 1
item = self.p_dane.item(j, i-(j*10))
if item.isSelected():
Xpoints.append(i+1)
self.selected.append(i)
Ypoints.append(int(item.text()))
self.qmc.axes.plot(Xpoints, Ypoints, 'ro')
# formatting of support lines
self.qmc.axes.xaxis.set_major_locator(MultipleLocator(10))
self.qmc.axes.xaxis.set_minor_locator(MultipleLocator(2))
# Prepare axis dimensions
Xmax = 40
if self.sample.Length() > 40:
Xmax = self.sample.Length() + 2
Ymax = max(self.sample.wypiszPomiary()) + 30
self.qmc.axes.axis([0, Xmax, 0, Ymax])
self.qmc.axes.xaxis.grid(
True,
'minor',
linewidth=0.4,
ls='-',
color='0.20')
self.qmc.axes.xaxis.grid(
True,
'major',
linewidth=1,
ls='-',
color='0.80')
self.qmc.axes.tick_params(axis='both', which='major', labelsize=10)
self.qmc.axes.set_axisbelow(True)
# ustawienie obszaru wykresu
self.qmc.axes.set_position([0.03, 0.05, 0.96, 0.94])
self.qmc.draw()
def odczytaj_dane(self, origin='copy'):
"""update sample - read all metadata and measurements which could be
altered by user. If origin of sample has to be modified use any
string in origin
"""
if origin == 'copy':
target = self.sample
else:
target = self.org_sample
for i, head in enumerate(self.headers):
ins = unicode(self.p_naglowek.item(i, 0).text())
if head not in ['Length'] and ins not in ['---', 0]:
target.wpiszMetadana(
head,
ins
)
rowNum = self.p_dane.rowCount()
colNum = self.p_dane.columnCount()
measurements = []
check = 'ok'
redraw = 0
for w in range(rowNum):
for k in range(colNum):
item = self.p_dane.item(w, k)
try:
if int(item.text()) != 0 and str(item.text()).isdigit:
measurements.append(int(item.text()))
# if after notOk we find number there is something wrong
# and we neef to reread measuremnts to tabel
if check == 'notOk':
redraw = 1
except:
check = 'notOk'
target.uaktualnijPom(measurements)
if redraw == 1:
self.wpisz_pomiary()
def dodaj_wartosc(self):
kk = 0
self.ile_wierszy = self.p_dane.rowCount()
self.ile_kol = self.p_dane.columnCount()
for wiersz in range(self.ile_wierszy):
for kolumna in range(self.ile_kol):
item = self.p_dane.item(wiersz, kolumna)
if self.p_dane.isItemSelected(item) == True and kk == 0:
kk = 1
text, ok = QInputDialog.getText(
self, 'Value', 'inser value: ')
if ok:
measurements = self.sample.wypiszPomiary()
measurements.insert((wiersz*10)+kolumna, int(text))
self.sample.uaktualnijPom(measurements)
self.wpisz_pomiary()
self.przerysuj_wykres()
def usun_wartosc(self):
sel = self.selected[:]
sel.reverse()
for s in sel:
self.sample.usunOstatniPomiar(position=int(s))
self.wpisz_pomiary()
self.przerysuj_wykres()
def wpisz_pomiary(self):
# przygotowanie labelek poziomych dla tablicy z pomiarami
self.w = (len(self.sample.wypiszPomiary()))/10
if (len(self.sample.wypiszPomiary())) % 10 > 0:
self.w += 1
i = 0
self.ww = []
while i < self.w:
self.ww.append(str(i*10))
i += 1
self.p_dane.blockSignals(True)
self.p_dane.clear()
self.p_dane.setRowCount(self.w)
self.p_dane.setVerticalHeaderLabels(self.ww)
self.p_dane.setAlternatingRowColors(True)
self.p_dane.setSortingEnabled(False)
# Dodajemy wartosci pomiarow
i = 0
j = 0
k = 0
measurements = self.sample.wypiszPomiary()
while k < len(measurements):
if j == 10:
j = 0
i += 1
komorka = QTableWidgetItem(str(measurements[k]))
self.p_dane.setItem(i, j, komorka)
j += 1
k += 1
# uzupelniamy pozostale pola pustymi wartosciami
while j % 10 != 0:
komorka = QTableWidgetItem("")
self.p_dane.setItem(i, j, komorka)
j += 1
self.p_dane.resizeColumnsToContents()
self.p_dane.blockSignals(False)
def podziel_wartosc(self):
if len(self.selected) != 1:
pass
else:
measurements = self.sample.wypiszPomiary()
val = measurements[self.selected[0]]
self.divideWindow = okno_podzialu(val)
self.divideWindow.exec_()
measurements.pop(self.selected[0])
self.sample.uaktualnijPom(measurements)
self.sample.dodajPomiar(self.divideWindow.val1,
position=self.selected[0])
self.sample.dodajPomiar(self.divideWindow.val0,
position=self.selected[0])
self.wpisz_pomiary()
self.przerysuj_wykres()
def polacz_wartosc(self):
measurements = self.sample.wypiszPomiary()
i = len(measurements) - 1
selectionRange = []
newMeasurements = []
while i > -1:
if i in self.selected:
selectionRange.append(measurements[i])
elif i not in self.selected:
if len(selectionRange) > 0:
newMeasurements.append(sum(selectionRange))
selectionRange = []
newMeasurements.append(measurements[i])
i -= 1
if len(selectionRange) > 0:
newMeasurements.append(selectionRange)
newMeasurements.reverse()
self.sample.uaktualnijPom(newMeasurements)
self.wpisz_pomiary()
self.przerysuj_wykres()
def schowaj(self):
self.odczytaj_dane()
self.hide()
def edytowana_kom_nagl(self):
# neccessary to maintain user specific date, otherwise it will be
# shuflled
row = self.p_naglowek.currentRow()
self.p_naglowek.blockSignals(True)
if self.headers[row] in ['DateBegin', 'DateEnd']:
head_temp = self.headers[row]
if head_temp == "DateBegin":
self.sample.ustawDateBegin(
int(self.p_naglowek.item(row, 0).text()))
it = QTableWidgetItem(str(self.sample.DateEnd()))
self.p_naglowek.setItem(self.headers.index("DateEnd"), 0, it)
if head_temp == "DateEnd":
self.sample.ustawDateEnd(
int(self.p_naglowek.item(row, 0).text()))
it = QTableWidgetItem(str(self.sample.DateBegin()))
self.p_naglowek.setItem(self.headers.index("DateBegin"), 0, it)
self.p_naglowek.blockSignals(False)
self.przerysuj_wykres()
def view(self):
"""create view and import layers"""
layer = QgsMapLayerRegistry.instance().mapLayer(
self.current_layers[0] )
uri = QgsDataSourceURI(layer.source())
mtch = re.match(r'(.+)_([^_]+)_rev_(head|\d+)', uri.schema())
schema = mtch.group(1)
assert(schema)
dlg = QDialog()
layout = QVBoxLayout(dlg)
button_box = QDialogButtonBox(dlg)
button_box.setStandardButtons(
QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
button_box.accepted.connect(dlg.accept)
button_box.rejected.connect(dlg.reject)
user_msg1 = QgsMessageBar(dlg)
user_msg1.pushInfo("Select:", "one [many] for single [multiple] "
"revisions. Fetching may take time.")
pcur = versioning_base.Db( psycopg2.connect(self.pg_conn_info()) )
pcur.execute("SELECT rev, commit_msg, branch, date, author "
"FROM "+schema+".revisions")
revs = pcur.fetchall()
pcur.close()
tblw = QTableWidget( dlg )
tblw.setRowCount(len(revs))
tblw.setColumnCount(6)
tblw.setSortingEnabled(True)
tblw.setHorizontalHeaderLabels(['Select','Revision', 'Commit Message',
'Branch', 'Date', 'Author'])
tblw.verticalHeader().setVisible(False)
for i, rev in enumerate(revs):
for j, item in enumerate(rev):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
tblw.setItem(i, 0, chkBoxItem)
tblw.setItem(i, j+1, QTableWidgetItem( str(item) ))
layout.addWidget( user_msg1 )
layout.addWidget( tblw )
layout.addWidget( button_box )
dlg.resize( 650, 300 )
if not dlg.exec_() :
return
rows = set()
revision_number_list = []
for i in range(len(revs)):
if tblw.item(i,0).checkState():
print "Revision "+ str(i + 1) +" will be fetched"
revision_number_list.append(i + 1)
rows.add(tblw.item(i,0).row())
progressMessageBar = self.iface.messageBar().createMessage("Querying "
"the database for revision(s) "+str(revision_number_list))
progress = QProgressBar()
progress.setMaximum(len(rows))
progress.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, self.iface.messageBar().INFO)
progress.setValue(0)
for i, row in enumerate(rows):
progress.setValue(i+1)
branch = revs[row][2]
rev = revs[row][0]
versioning_base.add_revision_view(uri.connectionInfo(),
schema, branch, rev )
grp_name = branch+' revision '+str(rev)
grp_idx = self.iface.legendInterface().addGroup( grp_name )
for layer_id in reversed(self.current_layers):
layer = QgsMapLayerRegistry.instance().mapLayer(layer_id)
new_uri = QgsDataSourceURI(layer.source())
new_uri.setDataSource(schema+'_'+branch+'_rev_'+str(rev),
new_uri.table(),
new_uri.geometryColumn(),
new_uri.sql(),
new_uri.keyColumn())
display_name = QgsMapLayerRegistry.instance().mapLayer(layer_id).name()
src = new_uri.uri().replace('()','')
new_layer = self.iface.addVectorLayer( src,
display_name, 'postgres')
self.iface.legendInterface().moveLayer( new_layer, grp_idx)
self.iface.messageBar().clearWidgets()
class OrbitCorrGeneral(QtGui.QWidget):
"""
A general orbit correction or local bump panel.
"""
def __init__(self, bpms, cors, parent = None):
super(OrbitCorrGeneral, self).__init__(parent)
self.bpms, self.cors = bpms, cors
self.sb = [bpm.sb for bpm in self.bpms]
self.x0, self.y0 = None, None
self._update_current_orbit()
self.table = QTableWidget(len(self.bpms), 9)
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
hdview = QHeaderView(Qt.Horizontal)
self.table.setHorizontalHeaderLabels(
['BPM Name', 's', "Beta X", "Beta Y",
"Eta X", 'X Bump', 'Y Bump', "Target X", "Target Y"])
self._twiss = getTwiss([b.name for b in self.bpms],
["s", "betax", "betay", "etax"])
for i,bpm in enumerate(self.bpms):
it = QTableWidgetItem(bpm.name)
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
self.table.setItem(i, 0, it)
it = QTableWidgetItem(str(bpm.sb))
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
#it.setMinimumWidth(80)
self.table.setItem(i, 1, it)
self.table.setItem(i, 2,
QTableWidgetItem("%.4f" % self._twiss[i,1]))
self.table.setItem(i, 3,
QTableWidgetItem("%.4f" % self._twiss[i,2]))
self.table.setItem(i, 4,
QTableWidgetItem("%.4f" % self._twiss[i,3]))
for j in range(5, 9):
it = QTableWidgetItem(str(0.0))
it.setData(Qt.DisplayRole, str(0.0))
it.setFlags(it.flags() | Qt.ItemIsEditable)
self.table.setItem(i, j, it)
# use the current orbit
#self.table.item(i,4).setData(Qt.DisplayRole, str(self.x0[i]))
#self.table.item(i,5).setData(Qt.DisplayRole, str(self.y0[i]))
#self.connect(self.table, SIGNAL("cellClicked(int, int)"),
# self._cell_clicked)
self.table.resizeColumnsToContents()
#self.table.horizontalHeader().setStretchLastSection(True)
#for i in range(4):
# print "width", i, self.table.columnWidth(i)
#self.table.setColumnWidth(0, 300)
self.table.setColumnWidth(1, 80)
vbox1 = QtGui.QVBoxLayout()
frmbox = QFormLayout()
self.base_orbit_box = QtGui.QComboBox()
#self.base_orbit_box.addItems([
# "Current Orbit", "All Zeros"])
self.base_orbit_box.addItems(["All Zeros", "Current Orbit"])
frmbox.addRow("Orbit Base", self.base_orbit_box)
grp = QtGui.QGroupBox("Local Bump")
grp.setLayout(frmbox)
vbox1.addWidget(grp)
frmbox = QFormLayout()
hln1 = QtGui.QFrame()
hln1.setLineWidth(3)
hln1.setFrameStyle(QtGui.QFrame.Sunken)
hln1.setFrameShape(QtGui.QFrame.HLine)
frmbox.addRow(hln1)
self.repeatbox = QSpinBox()
self.repeatbox.setRange(1, 20)
self.repeatbox.setValue(3)
# or connect the returnPressed() signal
frmbox.addRow("&Repeat correction", self.repeatbox)
self.rcondbox = QLineEdit()
self.rcondbox.setValidator(QDoubleValidator(0, 1, 0, self))
self.rcondbox.setText("1e-2")
frmbox.addRow("r&cond for SVD", self.rcondbox)
self.scalebox = QDoubleSpinBox()
self.scalebox.setRange(0.01, 5.00)
self.scalebox.setSingleStep(0.01)
self.scalebox.setValue(0.68)
frmbox.addRow("&Scale correctors", self.scalebox)
#hln2 = QtGui.QFrame()
#hln2.setLineWidth(3)
#hln2.setFrameStyle(QtGui.QFrame.Sunken)
#hln2.setFrameShape(QtGui.QFrame.HLine)
#frmbox.addRow(hln2)
self.progress = QProgressBar()
self.progress.setMaximum(self.repeatbox.value())
self.progress.setMaximumHeight(15)
frmbox.addRow("Progress", self.progress)
grp = QtGui.QGroupBox("Correction")
grp.setLayout(frmbox)
vbox1.addWidget(grp)
#vbox.addStretch(1.0)
#self.qdb = QDialogButtonBox(self)
#self.qdb.addButton("APP", QDialogButtonBox.ApplyRole)
#self.qdb.addButton("R", QDialogButtonBox.ResetRole)
#btn.setDefault(True)
#self.qdb.addButton(QDialogButtonBox.Cancel)
#self.qdb.addButton(QDialogButtonBox.Help)
gbox = QtGui.QGridLayout()
btn = QPushButton("Clear")
self.connect(btn, SIGNAL("clicked()"), self.resetBumps)
gbox.addWidget(btn, 0, 1)
self.correctOrbitBtn = QPushButton("Apply")
#self.correctOrbitBtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.correctOrbitBtn.setStyleSheet("QPushButton:disabled { color: gray }");
self.connect(self.correctOrbitBtn, SIGNAL("clicked()"), self.call_apply)
self.correctOrbitBtn.setDefault(True)
gbox.addWidget(self.correctOrbitBtn, 1, 1)
gbox.setColumnStretch(0, 1)
vbox1.addStretch()
vbox1.addLayout(gbox)
hbox1 = QtGui.QHBoxLayout()
hbox1.addWidget(self.table, 2)
hbox1.addLayout(vbox1, 0)
self.setLayout(hbox1)
self.connect(self.base_orbit_box,
SIGNAL("currentIndexChanged(QString)"),
self.updateTargetOrbit)
self.connect(self.repeatbox, SIGNAL("valueChanged(int)"),
self.progress.setMaximum)
self.connect(self.table, SIGNAL("cellChanged (int, int)"),
self.updateBump)
#self.updateTargetOrbit(self.base_orbit_box.currentText())
def _update_current_orbit(self):
pvx = [bpm.pv(field="x", handle="readback")[0] for bpm in self.bpms]
pvy = [bpm.pv(field="y", handle="readback")[0] for bpm in self.bpms]
self.x0 = [float(v) if v.ok else np.nan for v in catools.caget(pvx)]
self.y0 = [float(v) if v.ok else np.nan for v in catools.caget(pvy)]
def resetBumps(self):
jx0, jy0 = 5, 6
for i in range(self.table.rowCount()):
self.table.item(i, jx0).setData(Qt.DisplayRole, str(0.0))
self.table.item(i, jy0).setData(Qt.DisplayRole, str(0.0))
#self.updateTargetOrbit(self.base_orbit_box.currentText())
def call_apply(self):
#print "apply the orbit"
obt = []
jx, jy = 7, 8
for i in range(self.table.rowCount()):
x1,err = self.table.item(i, jx).data(Qt.DisplayRole).toFloat()
y1,err = self.table.item(i, jy).data(Qt.DisplayRole).toFloat()
obt.append([x1, y1])
self.correctOrbitBtn.setEnabled(False)
nrepeat = self.repeatbox.value()
kw = { "scale": float(self.scalebox.text()),
"rcond": float(self.rcondbox.text()) }
self.progress.setValue(0)
QApplication.processEvents()
for i in range(nrepeat):
err, msg = setLocalBump(self.bpms, self.cors, obt, **kw)
self.progress.setValue(i+1)
QApplication.processEvents()
if err != 0:
QtGui.QMessageBox.critical(
self, "Local Orbit Bump",
"ERROR: {0}\nAbort.".format(msg),
QtGui.QMessageBox.Ok)
#self.progress.setValue(0)
break
self.correctOrbitBtn.setEnabled(True)
def getTargetOrbit(self):
x = [self.table.item(i,7).data(Qt.DisplayRole).toFloat()[0]
for i in range(self.table.rowCount())]
y = [self.table.item(i,8).data(Qt.DisplayRole).toFloat()[0]
for i in range(self.table.rowCount())]
return (self.sb, x), (self.sb, y)
def updateTargetOrbit(self, baseobt):
if baseobt == "All Zeros":
jx0, jx1 = 5, 7
jy0, jy1 = 6, 8
for i in range(self.table.rowCount()):
it0 = self.table.item(i, jx0)
it1 = self.table.item(i, jx1)
it1.setData(Qt.DisplayRole, it0.data(Qt.DisplayRole))
it0 = self.table.item(i, jy0)
it1 = self.table.item(i, jy1)
it1.setData(Qt.DisplayRole, it0.data(Qt.DisplayRole))
elif baseobt == "Current Orbit":
self._update_current_orbit()
jx0, jx1 = 5, 7
jy0, jy1 = 6, 8
for i in range(self.table.rowCount()):
dx0,err = self.table.item(i, jx0).data(Qt.DisplayRole).toFloat()
it = self.table.item(i, jx1)
it.setData(Qt.DisplayRole, self.x0[i] + dx0)
dy0,err = self.table.item(i, jy0).data(Qt.DisplayRole).toFloat()
it = self.table.item(i, jy1)
it.setData(Qt.DisplayRole, self.y0[i] + dy0)
#self._update_orbit_plot()
x, y = self.getTargetOrbit()
self.emit(SIGNAL("targetOrbitChanged(PyQt_PyObject, PyQt_PyObject)"),
x, y)
def updateBump(self, row, col):
#print "updating ", row, col
if col == 5 or col == 6:
self.updateTargetOrbit(self.base_orbit_box.currentText())
class UpdateDialog(QDialog):
def __init__(self, update_script):
super(UpdateDialog, self).__init__(None, Qt.Window)
self.updates_to_run = []
self.setWindowTitle("emzed updates")
self.setWindowModality(Qt.WindowModal)
self.setMinimumWidth(600)
self.update_script = update_script
self.setup_widgets()
self.setup_layout()
self.connect_signals()
wd = QApplication.desktop().width()
hd = QApplication.desktop().height()
w = self.size().width()
h = self.size().height()
self.move((wd - w) / 2, (hd - h) / 2)
def showEvent(self, evt):
self.setCursor(Qt.WaitCursor)
class WorkerThread(QThread):
def run(self, script=self.update_script, parent=self):
try:
for method, args in script(parent.add_info_line, parent.add_update_info):
self.emit(SIGNAL("execute_method(PyQt_PyObject, PyQt_PyObject)"), method, args)
except:
import traceback
tb = traceback.format_exc()
self.emit(SIGNAL("execute_method(PyQt_PyObject, PyQt_PyObject)"), parent.add_info_line, (tb,))
self.emit(SIGNAL("update_query_finished()"))
self.t = WorkerThread()
self.connect(self.t, SIGNAL("update_query_finished()"), self.start_to_interact)
self.connect(
self.t, SIGNAL("execute_method(PyQt_PyObject,PyQt_PyObject)"), self.execute_method)
try:
self.t.start()
finally:
self.setCursor(Qt.ArrowCursor)
def execute_method(self, meth, args):
meth(*args)
def start_to_interact(self):
self.ok_button.setEnabled(True)
def setup_widgets(self):
self.label_info = QLabel("updates from exchange folder:")
self.info = QTextEdit(self)
self.info.setReadOnly(1)
self.label_updates = QLabel("updates from internet:")
self.updates = QTableWidget(0, 3)
self.updates.setHorizontalHeaderLabels(["updater", "info", "try updatde ?"])
self.updates.verticalHeader().hide()
self.updates.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.updates.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.ok_button = QPushButton("OK")
self.ok_button.setEnabled(False)
def setup_layout(self):
layout = QVBoxLayout()
self.setLayout(layout)
layout.addWidget(self.label_info)
layout.addWidget(self.info)
layout.addWidget(self.label_updates)
layout.addWidget(self.updates)
button_layout = QHBoxLayout()
button_layout.addStretch()
button_layout.addWidget(self.ok_button)
layout.addLayout(button_layout)
def connect_signals(self):
self.connect(self.ok_button, SIGNAL("pressed()"), self.accept)
def ok_button_pressed(self):
self.info.append("hi")
self.add_update_info("updater", "info")
def _item(self, content, is_checkable):
item = QTableWidgetItem(content)
if is_checkable:
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable | Qt.ItemIsSelectable)
return item
def add_update_info(self, updater_id, info, with_checkbox=True):
i = self.updates.rowCount()
self.updates.insertRow(i)
self.updates.setItem(i, 0, self._item(updater_id, False))
self.updates.setItem(i, 1, self._item(info, False))
if True or with_checkbox:
self.updates.setItem(i, 2, self._item("", True))
def add_info_line(self, txt):
self.info.append(txt)
def get_updates_to_run(self):
return self.updates_to_run
def accept(self):
for i in range(self.updates.rowCount()):
updater_id = str(self.updates.item(i, 0).text())
item = self.updates.item(i, 2)
if item is not None: # some cells in column are empty
checked = self.updates.item(i, 2).checkState() == Qt.Checked
if checked:
self.updates_to_run.append(updater_id)
super(UpdateDialog, self).accept()
class phonesDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().prm
self.currLocale = self.parent().prm['currentLocale']
self.currLocale.setNumberOptions(
self.currLocale.OmitGroupSeparator
| self.currLocale.RejectGroupSeparator)
screen = QDesktopWidget().screenGeometry()
self.resize(screen.width() / 2.5, screen.height() / 3)
self.isPlaying = False
#self.audioManager = audioManager(self)
#self.playThread = threadedPlayer(self)
self.sizer = QGridLayout()
self.v1Sizer = QVBoxLayout()
self.v2Sizer = QVBoxLayout()
self.calibSizer = QGridLayout()
self.phonesTableWidget = QTableWidget()
self.phonesTableWidget.setColumnCount(4)
self.phonesTableWidget.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.phonesTableWidget.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.phonesTableWidget.setHorizontalHeaderLabels([
self.tr('Phones'),
self.tr('Max Level'),
self.tr('Default'), 'id'
])
self.phonesTableWidget.hideColumn(3)
self.phonesTableWidget.cellDoubleClicked[int, int].connect(
self.onCellDoubleClicked)
#RENAME Phones BUTTON
self.renamePhonesButton = QPushButton(self.tr("Rename Phones"), self)
self.renamePhonesButton.clicked.connect(self.onEditLabel)
#Change Level Phones BUTTON
self.changeLevelPhonesButton = QPushButton(self.tr("Change Max Level"),
self)
self.changeLevelPhonesButton.clicked.connect(self.onEditMaxLevel)
#ADD Phones BUTTON
self.addPhonesButton = QPushButton(self.tr("Add Phones"), self)
self.addPhonesButton.clicked.connect(self.onClickAddPhonesButton)
#REMOVE Phones BUTTON
self.removePhonesButton = QPushButton(self.tr("Remove Phones"), self)
self.removePhonesButton.clicked.connect(self.onClickRemovePhonesButton)
#Set Default Phones BUTTON
self.setDefaultPhonesButton = QPushButton(self.tr("Set Default"), self)
self.setDefaultPhonesButton.clicked.connect(self.onEditDefault)
self.v1Sizer.addWidget(self.renamePhonesButton)
self.v1Sizer.addWidget(self.changeLevelPhonesButton)
self.v1Sizer.addWidget(self.addPhonesButton)
self.v1Sizer.addWidget(self.removePhonesButton)
self.v1Sizer.addWidget(self.setDefaultPhonesButton)
self.v1Sizer.addStretch()
self.phonesList = {}
for i in range(len(self.prm['phones']['phonesChoices'])):
currCount = i + 1
thisID = self.prm['phones']['phonesID'][i]
self.phonesList[thisID] = {}
self.phonesList[thisID]['label'] = self.prm['phones'][
'phonesChoices'][i]
self.phonesList[thisID]['maxLevel'] = self.prm['phones'][
'phonesMaxLevel'][i]
self.phonesList[thisID]['default'] = self.prm['phones'][
'defaultPhones'][i]
self.phonesTableWidget.setRowCount(currCount)
newItem = QTableWidgetItem(self.phonesList[thisID]['label'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 0, newItem)
newItem = QTableWidgetItem(
self.currLocale.toString(self.phonesList[thisID]['maxLevel']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 1, newItem)
newItem = QTableWidgetItem(self.phonesList[thisID]['default'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 2, newItem)
self.phonesList[thisID]['qid'] = QTableWidgetItem(thisID)
self.phonesTableWidget.setItem(currCount - 1, 3,
self.phonesList[thisID]['qid'])
##CALIBRATION TONE
n = 0
self.calLabel = QLabel(self.tr('Calibration Tone:'), self)
self.calibSizer.addWidget(self.calLabel, n, 0, 1, 2)
n = n + 1
self.toneFreqLabel = QLabel(self.tr('Frequency (Hz)'), self)
self.toneFreqTF = QLineEdit("1000")
self.toneFreqTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneFreqLabel, n, 0)
self.calibSizer.addWidget(self.toneFreqTF, n, 1)
n = n + 1
self.toneLevLabel = QLabel(self.tr('Level (dB)'), self)
self.toneLevTF = QLineEdit("60")
self.toneLevTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneLevLabel, n, 0)
self.calibSizer.addWidget(self.toneLevTF, n, 1)
n = n + 1
self.toneDurLabel = QLabel(self.tr('Duration (ms)'), self)
self.toneDurTF = QLineEdit("980")
self.toneDurTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneDurLabel, n, 0)
self.calibSizer.addWidget(self.toneDurTF, n, 1)
n = n + 1
self.toneRampsLabel = QLabel(self.tr('Ramps (ms)'), self)
self.toneRampsTF = QLineEdit("10")
self.toneRampsTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneRampsLabel, n, 0)
self.calibSizer.addWidget(self.toneRampsTF, n, 1)
n = n + 1
self.earLabel = QLabel(self.tr('Ear:'), self)
self.earChooser = QComboBox()
self.earChooser.addItems(
[self.tr("Right"),
self.tr("Left"),
self.tr("Both")])
self.calibSizer.addWidget(self.earLabel, n, 0)
self.calibSizer.addWidget(self.earChooser, n, 1)
n = n + 1
self.playCalibButton = QPushButton(self.tr("Play"), self)
self.playCalibButton.clicked.connect(self.onClickPlayCalibButton)
self.playCalibButton.setIcon(
QIcon.fromTheme("media-playback-start",
QIcon(":/media-playback-start")))
self.calibSizer.addWidget(self.playCalibButton, n, 0, 1, 2)
n = n + 1
self.stopCalibButton = QPushButton(self.tr("Stop"), self)
self.stopCalibButton.clicked.connect(self.onClickStopCalibButton)
self.stopCalibButton.setIcon(
QIcon.fromTheme("media-playback-stop",
QIcon(":/media-playback-stop")))
self.calibSizer.addWidget(self.stopCalibButton, n, 0, 1, 2)
if self.prm['pref']['sound']['playCommand'] in [
"alsaaudio", "pyaudio"
]:
self.stopCalibButton.show()
else:
self.stopCalibButton.hide()
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply
| QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
buttonBox.button(QDialogButtonBox.Apply).clicked.connect(
self.permanentApply)
self.sizer.addLayout(self.v1Sizer, 0, 0)
self.v2Sizer.addLayout(self.calibSizer)
self.v2Sizer.addStretch()
self.sizer.addWidget(self.phonesTableWidget, 0, 1)
self.sizer.addLayout(self.v2Sizer, 0, 2)
self.sizer.addWidget(buttonBox, 1, 1, 1, 2)
self.sizer.setColumnStretch(1, 2)
self.setLayout(self.sizer)
self.setWindowTitle(self.tr("Edit Phones"))
self.show()
def onCellDoubleClicked(self, row, col):
if col == 0:
self.onEditLabel()
elif col == 1:
self.onEditMaxLevel()
elif col == 2:
self.onEditDefault()
def onEditLabel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one label can be renamed at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('New name:')
text, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.phonesTableWidget.item(
self.phonesList[selectedSound]['qid'].row(),
0).setText(text)
self.phonesList[selectedSound]['label'] = text
def onEditMaxLevel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('Level:')
text, ok = QInputDialog.getDouble(
self, self.tr('Input Dialog'), msg,
self.phonesList[selectedSound]['maxLevel'])
if ok:
self.phonesTableWidget.item(
self.phonesList[selectedSound]['qid'].row(),
1).setText(self.currLocale.toString(text))
self.phonesList[selectedSound]['maxLevel'] = text
def onEditDefault(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
for i in range(self.phonesTableWidget.rowCount()):
self.phonesTableWidget.item(i, 2).setText("\u2012")
self.phonesList[str(self.phonesTableWidget.item(
i, 3).text())]['default'] = "\u2012"
self.phonesTableWidget.item(
self.phonesList[selectedSound]['qid'].row(),
2).setText("\u2713")
self.phonesList[selectedSound]['default'] = "\u2713"
def findSelectedItemIds(self):
selItems = self.phonesTableWidget.selectedItems()
selItemsRows = []
for i in range(len(selItems)):
selItemsRows.append(selItems[i].row())
selItemsRows = unique(selItemsRows)
selItemsIds = []
for i in range(len(selItemsRows)):
selItemsIds.append(
str(self.phonesTableWidget.item(selItemsRows[i], 3).text()))
return selItemsIds
def permanentApply(self):
self.prm['phones']['phonesChoices'] = []
self.prm['phones']['phonesMaxLevel'] = []
self.prm['phones']['defaultPhones'] = []
self.prm['phones']['phonesID'] = []
keys = sorted(self.phonesList.keys())
for key in keys:
self.prm['phones']['phonesChoices'].append(
str(self.phonesList[key]['label']))
self.prm['phones']['phonesMaxLevel'].append(
self.phonesList[key]['maxLevel'])
self.prm['phones']['defaultPhones'].append(
self.phonesList[key]['default'])
self.prm['phones']['phonesID'].append(key)
f = open(self.parent().prm['phonesPrefFile'], 'wb')
pickle.dump(self.parent().prm['phones'], f)
f.close()
for i in range(self.parent().phonesChooser.count()):
self.parent().phonesChooser.removeItem(0)
self.parent().phonesChooser.addItems(
self.prm['phones']['phonesChoices'])
def onClickAddPhonesButton(self):
keys = sorted(self.phonesList.keys())
thisID = str(int(keys[-1]) + 1)
currCount = self.phonesTableWidget.rowCount() + 1
self.phonesList[thisID] = {}
self.phonesList[thisID]['label'] = 'Phones' + ' ' + str(currCount)
self.phonesList[thisID]['maxLevel'] = 100
self.phonesList[thisID]['default'] = "\u2012"
self.phonesTableWidget.setRowCount(currCount)
newItem = QTableWidgetItem(self.phonesList[thisID]['label'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 0, newItem)
newItem = QTableWidgetItem(
self.currLocale.toString(self.phonesList[thisID]['maxLevel']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 1, newItem)
newItem = QTableWidgetItem(self.phonesList[thisID]['default'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 2, newItem)
self.phonesList[thisID]['qid'] = QTableWidgetItem(thisID)
self.phonesTableWidget.setItem(currCount - 1, 3,
self.phonesList[thisID]['qid'])
def onClickRemovePhonesButton(self):
if self.phonesTableWidget.rowCount() == 1:
ret = QMessageBox.warning(
self, self.tr("Warning"),
self.tr("Only one phone left. Cannot remove!"), QMessageBox.Ok)
else:
ids = self.findSelectedItemIds()
wasDefault = False
for i in range(len(ids)):
selectedPhones = ids[i]
if self.phonesTableWidget.item(
self.phonesList[selectedPhones]['qid'].row(),
2).text() == "\u2713":
wasDefault = True
self.phonesTableWidget.removeRow(
self.phonesList[selectedPhones]['qid'].row())
del self.phonesList[selectedPhones]
if wasDefault == True:
self.phonesTableWidget.item(0, 2).setText("\u2713")
self.phonesList[str(self.phonesTableWidget.item(
0, 3).text())]['default'] = "\u2713"
def onClickPlayCalibButton(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one label can be renamed at a time'))
return
elif len(ids) < 1:
QMessageBox.warning(self, self.tr('Warning'),
self.tr('Please, select a phone in the table'))
return
else:
selectedSound = ids[0]
calMaxLev = self.phonesList[selectedSound]['maxLevel']
frequency = self.currLocale.toDouble(self.toneFreqTF.text())[0]
level = self.currLocale.toDouble(self.toneLevTF.text())[0]
duration = self.currLocale.toDouble(self.toneDurTF.text())[0]
ramp = self.currLocale.toDouble(self.toneRampsTF.text())[0]
channel = self.earChooser.currentText()
fs = self.currLocale.toInt(self.parent().sampRateTF.text())[0]
nBits = self.currLocale.toInt(
self.parent().nBitsChooser.currentText())[0]
calTone = pureTone(frequency, 0, level, duration, ramp, channel,
fs, calMaxLev)
self.isPlaying = True
if self.prm['pref']['sound']['playCommand'] in [
"alsaaudio", "pyaudio"
]:
self.playThread = threadedAudioPlayer(self.parent())
else:
self.playThread = threadedExternalAudioPlayer(self.parent())
self.playThread.playThreadedSound(
calTone, fs, nBits, self.prm['pref']['sound']['playCommand'],
True, 'calibrationTone.wav')
if self.playThread.isFinished() == True:
self.isPlaying = False
def onClickStopCalibButton(self):
if self.isPlaying == True:
self.playThread.terminate()
#self.playThread.__del__()
def closeEvent(self, event):
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
event.accept()
def accept(self): #reimplement accept (i.e. ok button)
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
QDialog.accept(self)
def reject(self): #reimplement reject
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
QDialog.reject(self)
class MainWidget(QMainWindow):
def __init__(self, parent=None):
super(MainWidget, self).__init__(
parent,
windowTitle='GithubRemote',
windowIcon=QIcon(image_path('git.png')),
geometry=QRect(300, 300, 600, 372))
self.repo_pixmap = QPixmap(image_path('book_16.png'))
self.big_repo_pixmap = QPixmap(image_path('book_32.png'))
self.repo_fork_pixmap = QPixmap(image_path('book_fork_16.png'))
self.star_pixmap = QPixmap(image_path('star_16.png'))
self.big_star_pixmap = QPixmap(image_path('star_32.png'))
self.fork_pixmap = QPixmap(image_path('fork_16.png'))
self.eye_pixmap = QPixmap(image_path('eye_16.png'))
self.github = None
# Actions
self.repoAddAction = QAction(
QIcon(image_path('plus_48.png')),
'&Add Repo', self,
statusTip='Add a new repo')
self.repoAddAction.triggered.connect(self.repoAdd)
self.repoRemoveAction = QAction(
QIcon(image_path('minus.png')),
'&Remove Repo', self,
statusTip='Remove repo')
self.repoRemoveAction.triggered.connect(self.repoRemove)
self.repoRefreshAction = QAction(
QIcon(image_path('refresh.png')),
'Refresh', self,
statusTip='Refresh list of repos')
self.repoRefreshAction.triggered.connect(self.reposRefresh)
self.repoRefreshAction.triggered.connect(self.starsRefresh)
self.addAccountAction = QAction(
'Add Account', self,
statusTip='Add Account')
self.addAccountAction.triggered.connect(self.addAccount)
# userPushButton - Displays the current active username and
# image on the top right of the toolbar.
self.userButtonMenu = UserButtonMenu(32,32)
# ToolBar
self.toolBar = self.addToolBar('Main')
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolBar.addAction(self.repoAddAction)
self.toolBar.addAction(self.repoRemoveAction)
self.toolBar.addAction(self.repoRefreshAction)
self.toolBar.addWidget(spacer)
self.toolBar.addWidget(self.userButtonMenu)
# Menu
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
actionMenu = menuBar.addMenu('&Action')
fileMenu.addAction(self.addAccountAction)
actionMenu.addAction(self.repoAddAction)
actionMenu.addAction(self.repoRemoveAction)
actionMenu.addAction(self.repoRefreshAction)
# StatusBar
statusBar = self.statusBar()
self.setStatusBar(statusBar)
# reposTableWidget - Displays a list of the users repositories
self.reposTableWidget = QTableWidget(0, 5,
selectionBehavior = QAbstractItemView.SelectRows,
selectionMode = QAbstractItemView.SingleSelection,
editTriggers = QAbstractItemView.NoEditTriggers,
itemSelectionChanged = self.actionsUpdate)
self.reposTableWidget.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.reposTableWidget.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.reposTableWidget.horizontalHeader().setVisible(False)
self.reposTableWidget.verticalHeader().setVisible(False)
self.reposTableWidget.setShowGrid(False)
self.reposTableWidget.verticalHeader().setMinimumSectionSize(25)
# repoTab - Layout
reposTab = QWidget()
reposTabLayout = QVBoxLayout(reposTab)
reposTabLayout.addWidget(self.reposTableWidget)
reposTab.setLayout(reposTabLayout)
# starsTableWidget - Displays a list of the users repositories
self.starsTableWidget = QTableWidget(0, 5,
selectionBehavior = QAbstractItemView.SelectRows,
selectionMode = QAbstractItemView.SingleSelection,
editTriggers = QAbstractItemView.NoEditTriggers,
itemSelectionChanged = self.actionsUpdate)
self.starsTableWidget.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.starsTableWidget.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.starsTableWidget.horizontalHeader().setVisible(False)
self.starsTableWidget.verticalHeader().setVisible(False)
self.starsTableWidget.setShowGrid(False)
self.starsTableWidget.verticalHeader().setMinimumSectionSize(25)
# repoTab - Layout
starsTab = QWidget()
starsTabLayout = QVBoxLayout(starsTab)
starsTabLayout.addWidget(self.starsTableWidget)
starsTab.setLayout(starsTabLayout)
# Tab Widget
self.tabs = QTabWidget()
self.tabs.setTabBar(FlippedTabBar(self))
self.tabs.addTab(reposTab, QIcon(self.big_repo_pixmap), "repos")
self.tabs.addTab(starsTab, QIcon(self.big_star_pixmap), "stars")
self.tabs.setTabPosition(QTabWidget.West)
# Layout
self.setCentralWidget(self.tabs)
self.actionsUpdate()
self.show()
# Update
self.loadUserMenu()
if self.activeUserAction:
self.activeUserAction.setVisible(False)
self.authenticate()
self.actionsUpdate()
self.reposRefresh()
self.starsRefresh()
self.updateImage()
@waiting_effects
def updateImage(self):
try:
url = self.github.get_user().avatar_url
except (GithubException, AttributeError):
return
data = urllib.urlopen(url).read()
pixmap = QPixmap()
pixmap.loadFromData(data)
self.activeUserAction.setIcon(QIcon(pixmap))
self.userButtonMenu.setPixmap(pixmap)
self.userButtonMenu.setText(self.github.get_user().login)
@waiting_effects
def loadUserMenu(self):
action = None
for _, username, token in generate_tokens(CONFIG_PATH, 'github'):
try:
url = Github(token).get_user().avatar_url
except (GithubException, AttributeError):
action = QAction(username, self, triggered=self.changeActive)
self.userButtonMenu.addAction(action)
continue
data = urllib.urlopen(url).read()
pixmap = QPixmap()
pixmap.loadFromData(data)
action = QAction(QIcon(pixmap), username, self,
triggered=self.changeActive)
action.setIconVisibleInMenu(True)
self.userButtonMenu.addAction(action)
self.activeUserAction = action
def changeActive(self):
sender = self.sender()
self.activeUserAction.setVisible(True)
self.activeUserAction = sender
self.activeUserAction.setVisible(False)
self.authenticate()
self.actionsUpdate()
self.reposRefresh()
self.starsRefresh()
self.updateImage()
@waiting_effects
def reposRefresh(self):
self.reposTableWidget.clearContents()
try:
repos = self.github.get_user().get_repos()
self.reposTableWidget.setRowCount(self.github.get_user().public_repos)
except (GithubException, AttributeError):
return
for row, repo in enumerate(repos):
imageLabel = QLabel()
if repo.fork:
imageLabel.setPixmap(self.repo_fork_pixmap)
else:
imageLabel.setPixmap(self.repo_pixmap)
imageLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
imageLabel.setMargin(5)
self.reposTableWidget.setCellWidget(row, 0, imageLabel)
label = QLabel('<b>{}</b><br />{}'.format(
str(repo.name), str(repo.description)))
label.setAlignment(Qt.AlignVCenter)
label.setMargin(5)
label.setWordWrap(True)
self.reposTableWidget.setCellWidget(row, 1, label)
self.reposTableWidget.setItem(row, 2,
QTableWidgetItem(QIcon(self.star_pixmap), str(repo.stargazers_count)))
self.reposTableWidget.setItem(row, 3,
QTableWidgetItem(QIcon(self.eye_pixmap), str(repo.watchers_count)))
self.reposTableWidget.setItem(row, 4,
QTableWidgetItem(QIcon(self.fork_pixmap), str(repo.forks_count)))
self.reposTableWidget.resizeRowsToContents()
@waiting_effects
def starsRefresh(self):
self.starsTableWidget.clearContents()
try:
starred = self.github.get_user().get_starred()
self.starsTableWidget.setRowCount(self.github.get_user().public_repos)
except (GithubException, AttributeError):
return
for row, repo in enumerate(starred):
imageLabel = QLabel()
if repo.fork:
imageLabel.setPixmap(self.repo_fork_pixmap)
else:
imageLabel.setPixmap(self.repo_pixmap)
imageLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
imageLabel.setMargin(5)
self.starsTableWidget.setCellWidget(row, 0, imageLabel)
label = QLabel(u'<b>{}/{}</b><br />{}'.format(
unicode(repo.owner.login), unicode(repo.name), unicode(repo.description)))
label.setAlignment(Qt.AlignVCenter)
label.setMargin(5)
label.setWordWrap(True)
self.starsTableWidget.setCellWidget(row, 1, label)
self.starsTableWidget.setItem(row, 2,
QTableWidgetItem(QIcon(self.star_pixmap), '0'))
self.starsTableWidget.setItem(row, 3,
QTableWidgetItem(QIcon(self.eye_pixmap), str(repo.watchers_count)))
self.starsTableWidget.setItem(row, 4,
QTableWidgetItem(QIcon(self.fork_pixmap), str(repo.forks_count)))
self.starsTableWidget.resizeRowsToContents()
@waiting_effects
def authenticate(self):
if self.activeUserAction:
username = str(self.activeUserAction.text())
token = load_token(CONFIG_PATH, 'github', username)
self.github = Github(token)
else:
self.github = None
def actionsUpdate(self):
# TODO disable if no user is logged in
if self.github is None:
self.repoAddAction.setEnabled(False)
self.repoRemoveAction.setEnabled(False)
self.repoRefreshAction.setEnabled(False)
else:
self.repoAddAction.setEnabled(True)
self.repoRefreshAction.setEnabled(True)
if self._isARepoSelected():
self.repoRemoveAction.setEnabled(True)
else:
self.repoRemoveAction.setEnabled(False)
def addAccount(self):
wizard = AddAccountWizard(self)
if wizard.exec_():
username = str(wizard.field('username').toString())
token = str(wizard.field('token').toString())
store_token(CONFIG_PATH, 'github', username, token)
self.authenticate()
self.reposRefresh()
self.updateImage()
self.actionsUpdate()
def repoAdd(self):
wizard = AddRepoWizard(self.github, self)
if wizard.exec_():
self.github.get_user().create_repo(
str(wizard.field('name').toString()),
description=str(wizard.field('description').toString()),
private=bool(wizard.field('private').toBool()),
auto_init=bool(wizard.field('auto_init').toBool()),
gitignore_template=str(wizard.field('gitignore').toString()),
homepage=str(wizard.field('homepage').toString()),
has_wiki=bool(wizard.field('has_wiki').toBool()),
has_downloads=bool(wizard.field('has_downloads').toBool()),
has_issues=bool(wizard.field('has_issues').toBool()))
self.reposRefresh()
def repoRemove(self):
row = self._selectedRepoRow()
name = self.reposTableWidget.item(row, 0).text()
dialog = RepoRemoveDialog(self.github, name)
if dialog.exec_():
self.github.get_user().get_repo(str(name)).delete()
self.reposRefresh()
def _isARepoSelected(self):
""" Return True if a repo is selected else False """
if len(self.reposTableWidget.selectedItems()) > 0:
return True
else:
return False
def _selectedRepoRow(self):
""" Return the currently select repo """
# TODO - figure out what happens if no repo is selected
selectedModelIndexes = \
self.reposTableWidget.selectionModel().selectedRows()
for index in selectedModelIndexes:
return index.row()
class ExpensesDialog(QDialog):
holdc = {}
def __init__(self, session, parent=None):
super(ExpensesDialog, self).__init__(parent)
self.session = session
session = self.pullOnes('session', session)
self.sessionname = str(session['name']) + ' Session'
self.pagetitle = self.sessionname
self.tableFont = QFont('Century Gothic', 8)
#self.tableFont.setFamily('Century Gothic')
self.tableHeaderStyle = "::section {" "background-color: teal; color:white}"
#pull all CA
self.editID = 0
self.hold_account = {}
self.hold_expenses = {}
self.hold_expensesGroup = {}
from_label = QLabel('From:')
to_label = QLabel('To:')
self.fromData = QDateEdit()
self.toData = QDateEdit()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.fromData.setCalendarPopup(True)
self.toData.setDate(currentDate.currentDate())
self.toData.setCalendarPopup(True)
self.pull_btn = QPushButton()
self.pull_btn.setText("Load")
h_pull_box = QHBoxLayout()
h_pull_box.addWidget(from_label)
h_pull_box.addWidget(self.fromData)
h_pull_box.addWidget(to_label)
h_pull_box.addWidget(self.toData)
h_pull_box.addWidget(self.pull_btn)
expensesGroup = self.pullGroupExpenses()
account = self.pullAccount()
self.expenseGroupText = QLabel('Category')
self.expenseGroupData = QComboBox()
self.expenseGroupData.currentIndexChanged.connect(self.reloadExpenses)
self.expenseText = QLabel('Expenses')
self.expenseData = QComboBox()
self.amountText = QLabel('Amount')
self.amountData = QLineEdit()
self.amountData.setPlaceholderText('0000.00')
self.tellerText = QLabel('Teller/Reciept No.')
self.tellerData = QLineEdit()
self.tellerData.setPlaceholderText('xxxxxxxxx')
self.accountText = QLabel('Account')
self.accountData = QComboBox()
self.dateText = QLabel('Date')
self.dateData = QDateEdit()
self.dateData.setDate(currentDate.currentDate())
self.dateData.setCalendarPopup(True)
self.descriptionText = QLabel('Brief Description')
self.descriptionData = QPlainTextEdit()
self.descriptionData.move(200, 100)
hboz = QHBoxLayout()
self.gender = QLabel('State')
self.r1 = QRadioButton('Expenses')
self.r1.setChecked(True)
self.r2 = QRadioButton('Refund')
hboz.addWidget(self.r1)
hboz.addWidget(self.r2)
i = 0
for a in expensesGroup:
self.hold_expensesGroup[i] = a['id']
tex = str(a['name']).upper()
self.expenseGroupData.addItem(tex)
i += 1
i = 0
exp_key = self.hold_expensesGroup[self.expenseGroupData.currentIndex()]
expenses = self.pullExpenses(exp_key)
for a in expenses:
self.hold_expenses[i] = a['id']
tex = str(a['name']).upper()
self.expenseData.addItem(tex)
i += 1
i = 0
for a in account:
self.hold_account[i] = a['id']
tex = str(a['name']).upper()
self.accountData.addItem(tex)
i += 1
self.FormLayout = QFormLayout()
self.FormLayout.addRow(self.expenseGroupText, self.expenseGroupData)
self.FormLayout.addRow(self.expenseText, self.expenseData)
self.FormLayout.addRow(self.accountText, self.accountData)
self.FormLayout.addRow(self.tellerText, self.tellerData)
self.FormLayout.addRow(self.amountText, self.amountData)
self.FormLayout.addRow(self.gender, hboz)
self.FormLayout.addRow(self.dateText, self.dateData)
self.FormLayout.addRow(self.descriptionText, self.descriptionData)
groupBox1 = QGroupBox('Add Expenses')
groupBox1.setLayout(self.FormLayout)
self.pb = QPushButton()
self.pb.setObjectName("Add")
self.pb.setText("Add Expenses")
self.pb1 = QPushButton()
self.pb1.setObjectName("Edit")
self.pb1.setText("Edit Row")
self.pb1.setEnabled(False)
self.pb2 = QPushButton()
self.pb2.setObjectName("Close")
self.pb2.setText("Close")
self.pb3 = QPushButton()
self.pb3.setObjectName("Delete")
self.pb3.setText("Delete Row")
self.pb3.setEnabled(False)
self.pb4 = QPushButton()
self.pb4.setObjectName("Reset")
self.pb4.setText("Reset")
self.pb4.hide()
self.pb5 = QPushButton()
self.pb5.setObjectName("Change")
self.pb5.setText("Change Expenses")
self.pb5.hide()
self.pb6 = QPushButton()
self.pb6.setObjectName("Clear")
self.pb6.setText("Clear Selection")
self.pb6.setEnabled(False)
hbo = QHBoxLayout()
hbo.addWidget(self.pb)
hbo.addWidget(self.pb5)
hbo.addWidget(self.pb4)
hbo.addWidget(self.pb2)
groupBox2 = QGroupBox('Expenses Data')
groupBox2.setLayout(hbo)
self.cols = ['SN', 'EXPENSES', 'ACCOUNT', 'AMOUNT', 'DATE']
al = self.pullExpensesData()
if len(al) > 0:
al = al
else:
al = {}
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Expenses")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
#self.table.resizeColumnsToContents()
self.table.setRowCount(len(al))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in al:
#row id
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.setItem(i, 1,
QTableWidgetItem(str(q['expensename']).upper()))
self.table.setItem(i, 2,
QTableWidgetItem(str(q['accountname']).upper()))
zamt = str("{:,}".format(float(q['amount'])))
self.table.setItem(i, 3, QTableWidgetItem(zamt))
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 4, QTableWidgetItem(str(damt)))
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
v_pull_box = QVBoxLayout()
self.h1_pull_box = QVBoxLayout()
self.h1_pull_box.addWidget(self.table)
v_pull_box.addLayout(h_pull_box)
v_pull_box.addLayout(self.h1_pull_box)
h2_pull_box = QHBoxLayout()
h2_pull_box.addWidget(self.pb1)
h2_pull_box.addWidget(self.pb3)
h2_pull_box.addWidget(self.pb6)
v_pull_box.addLayout(h2_pull_box)
groupBox3 = QGroupBox()
groupBox3.setLayout(hbo)
groupBox2.setLayout(v_pull_box)
grid = QGridLayout()
grid.addWidget(groupBox1, 0, 0)
grid.addWidget(groupBox2, 0, 1, 2, 1)
grid.addWidget(groupBox3, 1, 0)
self.setLayout(grid)
self.connect(self.pb, SIGNAL("clicked()"), lambda: self.button_click())
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_editshow())
self.connect(self.pb2, SIGNAL("clicked()"),
lambda: self.button_close(self))
self.connect(self.pb3, SIGNAL("clicked()"),
lambda: self.button_delete())
self.connect(self.pb4, SIGNAL("clicked()"),
lambda: self.button_reset())
self.connect(self.pb5, SIGNAL("clicked()"), lambda: self.button_edit())
self.connect(self.pb6, SIGNAL("clicked()"),
lambda: self.button_clear())
self.connect(self.pull_btn,
SIGNAL("clicked()"),
lambda x=1: self.reloadTable(x))
self.setWindowTitle(self.pagetitle)
def handleHeaderMenu(self, pos):
print('column(%d)' % self.table.horizontalHeader().logicalIndexAt(pos))
menu = QMenu()
menu.addAction('Add')
menu.addAction('Delete')
menu.exec_(QCursor.pos())
def pullGroupExpenses(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 15, "active": 0})
return arr
def pullExpenses(self, a):
cn = Db()
arr = cn.selectn('datas', '', '', {"subID": a})
return arr
def pullAccount(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 20, "active": 0})
return arr
def pullExpensesData(self):
st_date = self.fromData.date().toPyDate()
en_date = self.toData.date().toPyDate()
st_date = time.mktime(st_date.timetuple())
en_date = time.mktime(en_date.timetuple())
db = 'school_expenses' + str(self.session)
cn = Db()
arr = cn.selectExpenseDate(db, st_date, en_date)
return arr
def mySelectTable(self):
'''
get the selected rpws in a table
returns list or row ids
'''
sels = self.table.selectedIndexes()
sels = self.table.selectionModel().selectedRows()
park = []
park1 = []
for j in sels:
park.append(j.row())
for i in set(park):
selected = self.table.item(i, 0).text()
park1.append(selected)
return park1
def editRow(self, a):
_session = self.session
g = Db()
db = 'school_expenses' + str(_session)
data = g.selectn(db, '', 1, {'id': a})
if len(data) > 0:
self.editID = int(data['id'])
if float(data['amount']) < 0:
amt = float(data['amount']) * -1
self.amountData.setText(str(amt))
self.r1.setChecked(True)
else:
amt = float(data['amount'])
self.amountData.setText(str(amt))
self.r2.setChecked(True)
self.descriptionData.clear()
self.descriptionData.insertPlainText(str(data['description']))
self.tellerData.setText(str(data['teller']))
acID = self.hold_account.keys()[self.hold_account.values().index(
data['accountID'])]
self.accountData.setCurrentIndex(acID)
exID = self.hold_expenses.keys()[self.hold_expenses.values().index(
data['expenseID'])]
self.expenseData.setCurrentIndex(exID)
def reloadExpenses(self):
cat = self.hold_expensesGroup[self.expenseGroupData.currentIndex()]
expenses = self.pullExpenses(cat)
self.expenseData.clear()
self.hold_expenses = {}
i = 0
for a in expenses:
self.hold_expenses[i] = a['id']
tex = str(a['name']).upper()
self.expenseData.addItem(tex)
i += 1
def reloadTable(self, a):
data = self.pullExpensesData()
self.table.close()
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Expenses")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
self.table.resizeColumnsToContents()
self.table.setRowCount(len(data))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in data:
#row id
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.setItem(i, 1,
QTableWidgetItem(str(q['expensename']).upper()))
self.table.setItem(i, 2,
QTableWidgetItem(str(q['accountname']).upper()))
zamt = str("{:,}".format(float(q['amount'])))
self.table.setItem(i, 3, QTableWidgetItem(zamt))
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 4, QTableWidgetItem(str(damt)))
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
self.h1_pull_box.addWidget(self.table)
self.table.show()
def pullOnes(self, a, b):
cn = Db()
arr = cn.selectn(a, '', 1, {'id': b})
return arr
def confirmSelection(self):
item = self.mySelectTable()
if len(item) == 1:
self.pb1.setEnabled(True)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
elif len(item) > 1:
self.pb1.setEnabled(False)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
else:
self.pb1.setEnabled(False)
self.pb3.setEnabled(False)
self.pb6.setEnabled(False)
def button_close(self, b):
b.close()
def button_editshow(self):
item = self.mySelectTable()
self.editRow(item[0])
self.pb.hide()
self.pb4.show()
self.pb5.show()
def button_delete(self):
item = self.mySelectTable()
_session = self.session
g = Db()
db = 'school_expenses' + str(_session)
for j in item:
g.delete(db, {'id': j})
self.reloadTable(1)
def button_edit(self):
_session = self.session
_amount = self.amountData.text()
_teller = self.tellerData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_account = self.hold_account[self.accountData.currentIndex()]
_expense = self.hold_expenses[self.expenseData.currentIndex()]
if self.r1.isChecked():
_amount = float(_amount)
else:
_amount = float(_amount) * -1
arr = {}
if _amount and not (_amount
== 0) and int(_expense) > 0 and int(_account) > 0:
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['accountID'] = _account
arr['expenseID'] = _expense
arr['teller'] = _teller
ups = {}
ups['id'] = self.editID
if int(self.editID) > 0:
db = 'school_expenses' + str(_session)
g = Db()
g.update(db, arr, ups)
if int(self.editID) > 0:
self.button_reset()
def button_reset(self):
self.reloadTable(1)
self.amountData.setText('')
self.descriptionData.clear()
self.tellerData.setText('')
self.pb4.hide()
self.pb5.hide()
self.pb.show()
self.editID = 0
self.button_clear()
self.confirmSelection()
def button_clear(self):
self.table.selectionModel().clearSelection()
def button_click(self):
_session = self.session
_amount = self.amountData.text()
_teller = self.tellerData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_account = self.hold_account[self.accountData.currentIndex()]
_expense = self.hold_expenses[self.expenseData.currentIndex()]
if self.r1.isChecked():
_amount = float(_amount)
else:
_amount = float(_amount) * -1
arr = {}
if _amount and not (_amount
== 0) and int(_expense) > 0 and int(_account) > 0:
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['accountID'] = _account
arr['expenseID'] = _expense
arr['teller'] = _teller
db = 'school_expenses' + str(_session)
g = Db()
ins = g.insert(db, arr)
if int(ins) > 0:
self.button_reset()
class NewRelationDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.setWindowTitle(self.tr("Nueva Relación"))
vbox = QVBoxLayout(self)
hbox = QHBoxLayout()
self._line_relation_name = QLineEdit()
hbox.addWidget(QLabel(self.tr("Nombre:")))
hbox.addWidget(self._line_relation_name)
vbox.addLayout(hbox)
vbox.addWidget(QLabel(
self.tr("La primera fila corresponde a los campos")))
hbox = QHBoxLayout()
btn_add_column = QPushButton(self.tr("Agregar Columna"))
hbox.addWidget(btn_add_column)
btn_add_tuple = QPushButton(self.tr("Agregar Tupla"))
hbox.addWidget(btn_add_tuple)
btn_remove_column = QPushButton(self.tr("Eliminar Columna"))
hbox.addWidget(btn_remove_column)
btn_remove_tuple = QPushButton(self.tr("Eliminar Tupla"))
hbox.addWidget(btn_remove_tuple)
vbox.addLayout(hbox)
self._table = QTableWidget()
vbox.addWidget(self._table)
self._table.setRowCount(1)
self._table.setColumnCount(2)
self._table.setItem(0, 0, QTableWidgetItem("Campo 1"))
self._table.setItem(0, 1, QTableWidgetItem("Campo 2"))
hbox = QHBoxLayout()
hbox.addItem(QSpacerItem(1, 0, QSizePolicy.Expanding))
btn_ok = QPushButton(self.tr("Aceptar"))
hbox.addWidget(btn_ok)
btn_cancel = QPushButton(self.tr("Cancelar"))
hbox.addWidget(btn_cancel)
vbox.addLayout(hbox)
# Connections
self.connect(btn_add_column, SIGNAL("clicked()"),
self.__add_column)
self.connect(btn_remove_column, SIGNAL("clicked()"),
self.__remove_column)
self.connect(btn_add_tuple, SIGNAL("clicked()"),
self.__add_tuple)
self.connect(btn_remove_tuple, SIGNAL("clicked()"),
self.__remove_tuple)
self.connect(btn_ok, SIGNAL("clicked()"),
self.__create_table)
self.connect(btn_cancel, SIGNAL("clicked()"),
self.close)
def __add_column(self):
columns = self._table.columnCount()
self._table.insertColumn(columns)
def __remove_column(self):
current = self._table.currentColumn()
self._table.removeColumn(current)
def __add_tuple(self):
tuples = self._table.rowCount()
self._table.insertRow(tuples)
def __remove_tuple(self):
current = self._table.currentRow()
self._table.removeRow(current)
def __create_table(self):
# Name of relation
name = self._line_relation_name.text()
if not name.strip():
QMessageBox.critical(self, self.tr("Error"),
self.tr("Nombre de relación no especificado"))
return
rows = self._table.rowCount()
columns = self._table.columnCount()
rel = relation.Relation()
# Header of relation
fields = []
for i in range(columns):
text = self._table.item(0, i).text()
if not text.strip():
QMessageBox.critical(self, self.tr("Error"),
self.tr("Nombre de campo inválido"))
return
fields.append(text)
rel.fields = fields
# Data
data = {}
for row in range(1, rows):
reg = []
for column in range(columns):
item = self._table.item(row, column)
if item is None or not item.text().strip():
QMessageBox.critical(self, self.tr("Campo vacío"),
self.tr("El campo {0}:{1} está "
"vacío").format(row + 1, column + 1))
return
reg.append(self._table.item(row, column).text())
data[row, column] = self._table.item(row, column).text()
rel.insert(reg)
# Add table and relation
table_widget = Pireal.get_service("container").table_widget
table_widget.add_table(rows - 1, columns, name, data, fields)
table_widget.relations[name] = rel
self.close()
class MainWidget(QMainWindow):
def __init__(self, parent=None):
super(MainWidget,
self).__init__(parent,
windowTitle='GithubRemote',
windowIcon=QIcon(image_path('git.png')),
geometry=QRect(300, 300, 600, 372))
self.repo_pixmap = QPixmap(image_path('book_16.png'))
self.big_repo_pixmap = QPixmap(image_path('book_32.png'))
self.repo_fork_pixmap = QPixmap(image_path('book_fork_16.png'))
self.star_pixmap = QPixmap(image_path('star_16.png'))
self.big_star_pixmap = QPixmap(image_path('star_32.png'))
self.fork_pixmap = QPixmap(image_path('fork_16.png'))
self.eye_pixmap = QPixmap(image_path('eye_16.png'))
self.github = None
# Actions
self.repoAddAction = QAction(QIcon(image_path('plus_48.png')),
'&Add Repo',
self,
statusTip='Add a new repo')
self.repoAddAction.triggered.connect(self.repoAdd)
self.repoRemoveAction = QAction(QIcon(image_path('minus.png')),
'&Remove Repo',
self,
statusTip='Remove repo')
self.repoRemoveAction.triggered.connect(self.repoRemove)
self.repoRefreshAction = QAction(QIcon(image_path('refresh.png')),
'Refresh',
self,
statusTip='Refresh list of repos')
self.repoRefreshAction.triggered.connect(self.reposRefresh)
self.repoRefreshAction.triggered.connect(self.starsRefresh)
self.addAccountAction = QAction('Add Account',
self,
statusTip='Add Account')
self.addAccountAction.triggered.connect(self.addAccount)
# userPushButton - Displays the current active username and
# image on the top right of the toolbar.
self.userButtonMenu = UserButtonMenu(32, 32)
# ToolBar
self.toolBar = self.addToolBar('Main')
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolBar.addAction(self.repoAddAction)
self.toolBar.addAction(self.repoRemoveAction)
self.toolBar.addAction(self.repoRefreshAction)
self.toolBar.addWidget(spacer)
self.toolBar.addWidget(self.userButtonMenu)
# Menu
menuBar = self.menuBar()
fileMenu = menuBar.addMenu('&File')
actionMenu = menuBar.addMenu('&Action')
fileMenu.addAction(self.addAccountAction)
actionMenu.addAction(self.repoAddAction)
actionMenu.addAction(self.repoRemoveAction)
actionMenu.addAction(self.repoRefreshAction)
# StatusBar
statusBar = self.statusBar()
self.setStatusBar(statusBar)
# reposTableWidget - Displays a list of the users repositories
self.reposTableWidget = QTableWidget(
0,
5,
selectionBehavior=QAbstractItemView.SelectRows,
selectionMode=QAbstractItemView.SingleSelection,
editTriggers=QAbstractItemView.NoEditTriggers,
itemSelectionChanged=self.actionsUpdate)
self.reposTableWidget.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.reposTableWidget.horizontalHeader().setResizeMode(
1, QHeaderView.Stretch)
self.reposTableWidget.horizontalHeader().setVisible(False)
self.reposTableWidget.verticalHeader().setVisible(False)
self.reposTableWidget.setShowGrid(False)
self.reposTableWidget.verticalHeader().setMinimumSectionSize(25)
# repoTab - Layout
reposTab = QWidget()
reposTabLayout = QVBoxLayout(reposTab)
reposTabLayout.addWidget(self.reposTableWidget)
reposTab.setLayout(reposTabLayout)
# starsTableWidget - Displays a list of the users repositories
self.starsTableWidget = QTableWidget(
0,
5,
selectionBehavior=QAbstractItemView.SelectRows,
selectionMode=QAbstractItemView.SingleSelection,
editTriggers=QAbstractItemView.NoEditTriggers,
itemSelectionChanged=self.actionsUpdate)
self.starsTableWidget.horizontalHeader().setResizeMode(
QHeaderView.ResizeToContents)
self.starsTableWidget.horizontalHeader().setResizeMode(
1, QHeaderView.Stretch)
self.starsTableWidget.horizontalHeader().setVisible(False)
self.starsTableWidget.verticalHeader().setVisible(False)
self.starsTableWidget.setShowGrid(False)
self.starsTableWidget.verticalHeader().setMinimumSectionSize(25)
# repoTab - Layout
starsTab = QWidget()
starsTabLayout = QVBoxLayout(starsTab)
starsTabLayout.addWidget(self.starsTableWidget)
starsTab.setLayout(starsTabLayout)
# Tab Widget
self.tabs = QTabWidget()
self.tabs.setTabBar(FlippedTabBar(self))
self.tabs.addTab(reposTab, QIcon(self.big_repo_pixmap), "repos")
self.tabs.addTab(starsTab, QIcon(self.big_star_pixmap), "stars")
self.tabs.setTabPosition(QTabWidget.West)
# Layout
self.setCentralWidget(self.tabs)
self.actionsUpdate()
self.show()
# Update
self.loadUserMenu()
if self.activeUserAction:
self.activeUserAction.setVisible(False)
self.authenticate()
self.actionsUpdate()
self.reposRefresh()
self.starsRefresh()
self.updateImage()
@waiting_effects
def updateImage(self):
try:
url = self.github.get_user().avatar_url
except (GithubException, AttributeError):
return
data = urllib.urlopen(url).read()
pixmap = QPixmap()
pixmap.loadFromData(data)
self.activeUserAction.setIcon(QIcon(pixmap))
self.userButtonMenu.setPixmap(pixmap)
self.userButtonMenu.setText(self.github.get_user().login)
@waiting_effects
def loadUserMenu(self):
action = None
for _, username, token in generate_tokens(CONFIG_PATH, 'github'):
try:
url = Github(token).get_user().avatar_url
except (GithubException, AttributeError):
action = QAction(username, self, triggered=self.changeActive)
self.userButtonMenu.addAction(action)
continue
data = urllib.urlopen(url).read()
pixmap = QPixmap()
pixmap.loadFromData(data)
action = QAction(QIcon(pixmap),
username,
self,
triggered=self.changeActive)
action.setIconVisibleInMenu(True)
self.userButtonMenu.addAction(action)
self.activeUserAction = action
def changeActive(self):
sender = self.sender()
self.activeUserAction.setVisible(True)
self.activeUserAction = sender
self.activeUserAction.setVisible(False)
self.authenticate()
self.actionsUpdate()
self.reposRefresh()
self.starsRefresh()
self.updateImage()
@waiting_effects
def reposRefresh(self):
self.reposTableWidget.clearContents()
try:
repos = self.github.get_user().get_repos()
self.reposTableWidget.setRowCount(
self.github.get_user().public_repos)
except (GithubException, AttributeError):
return
for row, repo in enumerate(repos):
imageLabel = QLabel()
if repo.fork:
imageLabel.setPixmap(self.repo_fork_pixmap)
else:
imageLabel.setPixmap(self.repo_pixmap)
imageLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
imageLabel.setMargin(5)
self.reposTableWidget.setCellWidget(row, 0, imageLabel)
label = QLabel('<b>{}</b><br />{}'.format(str(repo.name),
str(repo.description)))
label.setAlignment(Qt.AlignVCenter)
label.setMargin(5)
label.setWordWrap(True)
self.reposTableWidget.setCellWidget(row, 1, label)
self.reposTableWidget.setItem(
row, 2,
QTableWidgetItem(QIcon(self.star_pixmap),
str(repo.stargazers_count)))
self.reposTableWidget.setItem(
row, 3,
QTableWidgetItem(QIcon(self.eye_pixmap),
str(repo.watchers_count)))
self.reposTableWidget.setItem(
row, 4,
QTableWidgetItem(QIcon(self.fork_pixmap),
str(repo.forks_count)))
self.reposTableWidget.resizeRowsToContents()
@waiting_effects
def starsRefresh(self):
self.starsTableWidget.clearContents()
try:
starred = self.github.get_user().get_starred()
self.starsTableWidget.setRowCount(
self.github.get_user().public_repos)
except (GithubException, AttributeError):
return
for row, repo in enumerate(starred):
imageLabel = QLabel()
if repo.fork:
imageLabel.setPixmap(self.repo_fork_pixmap)
else:
imageLabel.setPixmap(self.repo_pixmap)
imageLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
imageLabel.setMargin(5)
self.starsTableWidget.setCellWidget(row, 0, imageLabel)
label = QLabel(u'<b>{}/{}</b><br />{}'.format(
unicode(repo.owner.login), unicode(repo.name),
unicode(repo.description)))
label.setAlignment(Qt.AlignVCenter)
label.setMargin(5)
label.setWordWrap(True)
self.starsTableWidget.setCellWidget(row, 1, label)
self.starsTableWidget.setItem(
row, 2, QTableWidgetItem(QIcon(self.star_pixmap), '0'))
self.starsTableWidget.setItem(
row, 3,
QTableWidgetItem(QIcon(self.eye_pixmap),
str(repo.watchers_count)))
self.starsTableWidget.setItem(
row, 4,
QTableWidgetItem(QIcon(self.fork_pixmap),
str(repo.forks_count)))
self.starsTableWidget.resizeRowsToContents()
@waiting_effects
def authenticate(self):
if self.activeUserAction:
username = str(self.activeUserAction.text())
token = load_token(CONFIG_PATH, 'github', username)
self.github = Github(token)
else:
self.github = None
def actionsUpdate(self):
# TODO disable if no user is logged in
if self.github is None:
self.repoAddAction.setEnabled(False)
self.repoRemoveAction.setEnabled(False)
self.repoRefreshAction.setEnabled(False)
else:
self.repoAddAction.setEnabled(True)
self.repoRefreshAction.setEnabled(True)
if self._isARepoSelected():
self.repoRemoveAction.setEnabled(True)
else:
self.repoRemoveAction.setEnabled(False)
def addAccount(self):
wizard = AddAccountWizard(self)
if wizard.exec_():
username = str(wizard.field('username').toString())
token = str(wizard.field('token').toString())
store_token(CONFIG_PATH, 'github', username, token)
self.authenticate()
self.reposRefresh()
self.updateImage()
self.actionsUpdate()
def repoAdd(self):
wizard = AddRepoWizard(self.github, self)
if wizard.exec_():
self.github.get_user().create_repo(
str(wizard.field('name').toString()),
description=str(wizard.field('description').toString()),
private=bool(wizard.field('private').toBool()),
auto_init=bool(wizard.field('auto_init').toBool()),
gitignore_template=str(wizard.field('gitignore').toString()),
homepage=str(wizard.field('homepage').toString()),
has_wiki=bool(wizard.field('has_wiki').toBool()),
has_downloads=bool(wizard.field('has_downloads').toBool()),
has_issues=bool(wizard.field('has_issues').toBool()))
self.reposRefresh()
def repoRemove(self):
row = self._selectedRepoRow()
name = self.reposTableWidget.item(row, 0).text()
dialog = RepoRemoveDialog(self.github, name)
if dialog.exec_():
self.github.get_user().get_repo(str(name)).delete()
self.reposRefresh()
def _isARepoSelected(self):
""" Return True if a repo is selected else False """
if len(self.reposTableWidget.selectedItems()) > 0:
return True
else:
return False
def _selectedRepoRow(self):
""" Return the currently select repo """
# TODO - figure out what happens if no repo is selected
selectedModelIndexes = \
self.reposTableWidget.selectionModel().selectedRows()
for index in selectedModelIndexes:
return index.row()
class PvTunerDlg(QDialog):
COL = 6
COL_ELEMENT = 0
COL_FIELD = 1
COL_PV = 2
COL_STEPSIZE = 3
COL_READBACK = 4
COL_SETPOINT = 5
FMT_READBACK = "%.4e"
def __init__(self, parent=None):
super(PvTunerDlg, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
#self.inputBox = QLineEdit("PL2G2C01A.x")
#self.inputBox = QLineEdit("CXH2G6C01B.x")
self.inputBox = QLineEdit("PL2G2C01A")
addPvBtn = QPushButton("add")
self.table = QTableWidget(0, PvTunerDlg.COL)
self.table.setHorizontalHeaderLabels(
["Element", "Field", "PV", "Stepsize", "Readback", "setpoint"])
#self.table.horizontalHeader().setStretchLastSection(True)
#self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok)
box = QGridLayout()
box.addWidget(self.inputBox, 0, 0)
box.addWidget(addPvBtn, 0, 1)
box.addWidget(self.table, 1, 0, 1, 2)
box.addWidget(buttonBox, 2, 0)
self.setLayout(box)
self.pvs_rb = []
self.pvs_rb_val_flat = []
self.pvs_sp = []
self.pvmoni = []
self.spinbox = []
self.connect(addPvBtn, SIGNAL("clicked()"), self.addPv)
self.connect(buttonBox, SIGNAL("accepted()"), self.accept)
#self.connect(self.table, SIGNAL("cellChanged"), self.updatePv)
self.connect(buttonBox.button(QDialogButtonBox.Ok),
SIGNAL("clicked()"), self.close)
self.connect(self.table, SIGNAL("cellClicked(int, int)"),
self._cell_clicked)
def _cell_clicked(self, row, column):
#print row, column
if column in [self.COL_PV, self.COL_STEPSIZE]:
item = self.table.item(row, column)
if not item: return
item.setFlags(item.flags() | Qt.ItemIsEditable)
def _appendRecord(self, name):
vec = name.split('.')
if len(vec) > 2:
QMessageBox.critical(None, "ERROR", "format is wrong")
return
if len(vec) == 1:
elem, field = vec[0], 'value'
elif len(vec) == 2:
elem, field = vec
elemobj = hla.getElements(elem)
if elemobj:
# pvsrb is a list
pvsrb = elemobj.pv(field=field, handle='readback')
self.pvs_rb.append(pvsrb)
pvssp = elemobj.pv(field=field, handle='setpoint')
self.pvs_sp.append(pvssp)
else:
QMessageBox.critical(None, "ERROR", "element %s not found" % elem)
return
# expand one row
m, n = self.table.rowCount(), self.table.columnCount()
self.table.insertRow(m)
# add cells
item = QTableWidgetItem(elem)
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_ELEMENT, item)
item = QTableWidgetItem(field)
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_FIELD, item)
item = QTableWidgetItem(', '.join(pvsrb))
#item.setFlags(Qt.ItemIsSelectable|Qt.ItemIsEnabled)
self.table.setItem(m, self.COL_PV, item)
readval = ['%.4e' % v for v in caget(pvsrb)]
item = QTableWidgetItem(', '.join(readval))
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_READBACK, item)
# set the stepsize of PV
stepsize = 0.00001
if pvssp:
item = QTableWidgetItem('%f' % stepsize)
item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.table.setItem(m, self.COL_STEPSIZE, item)
self.spinbox.append(QDoubleSpinBox(self.table))
self.spinbox[-1].setRange(-100, 100)
#self.spinbox[-1].setValue(float(10.0))
self.spinbox[-1].setSingleStep(stepsize)
self.spinbox[-1].setDecimals(10)
self.spinbox[-1].valueChanged.connect(self._writePv)
self.table.setCellWidget(m, self.COL_SETPOINT, self.spinbox[-1])
sp = float(caget(pvssp)[0])
#print "setpoint:", pvssp, sp, type(sp)
self.spinbox[-1].setValue(-1e-5)
#print "connected", self.spinbox[-1].value()
else:
item = self.table.item(m, self.COL_STEPSIZE)
if item: item.setFlags(item.flags() & (~Qt.ItemIsEditable))
item = self.table.item(m, self.COL_SETPOINT)
if item: item.setFlags(item.flags() & (~Qt.ItemIsEditable))
self.spinbox.append(None)
self.table.resizeColumnsToContents()
def addPv(self):
self._appendRecord(str(self.inputBox.text()))
self._updateMonitors()
def minimalSizeHint(self):
return QSize(800, 600)
def _writePv(self, v):
"""
"""
c = QObject.sender(self)
i = self.spinbox.index(c)
#print i, c.text(), "changed"
#print self.pvs_sp[i], v
caput(self.pvs_sp[i], v)
def _updateMonitors(self):
"""
prepare the PV list for camonitor
"""
#print "Updating monitors"
pvs = []
self.pvs_rb_val = []
for i in range(self.table.rowCount()):
for j in range(len(self.pvs_rb[i])):
self.pvs_rb_val.append([i, 0.0])
pvs.extend(self.pvs_rb[i])
for p in self.pvmoni:
p.close()
self.pvmoni = camonitor(pvs, self._updatePvValues)
#print self.pvmoni
#print pvs
#print self.pvs_rb_val
def _updatePvValues(self, val, idx):
#print idx, val
s = []
for i, v in enumerate(self.pvs_rb_val):
if v[0] == self.pvs_rb_val[idx][0]:
s.append(self.FMT_READBACK % val)
#print s
item = self.table.item(self.pvs_rb_val[idx][0], self.COL_READBACK)
item.setText(','.join(s))
def closePvMonitors(self):
#print "Closing PV Monitors"
for p in self.pvmoni:
p.close()
pass
def closeEvent(self, event):
self.closePvMonitors()
event.accept()
def close(self):
self.closePvMonitors()
return True
class SentenceFillDlg(QDialog, ui_sentencefilldlg.Ui_SentenceFillDlg):
def __init__(self, tableName, rangeValues, parent=None):
super(SentenceFillDlg, self).__init__(parent)
self.tableName = tableName
self.rangeValues = rangeValues
self.setupUi(self)
self.initUI()
def initUI(self):
fontLabel = QFont('SansSerif', 14)
self.setMinimumSize(1200, 600)
self.resize(1200, 600)
self.sentenceToFillTable = QTableWidget(5, 1, self)
self.sentenceToFillTable.setGeometry(QRect(70, 60, 800, 400))
self.sentenceToFillTable.setColumnCount(1)
item = QTableWidgetItem()
item.setText('Sentences To Match')
font = QFont()
font.setBold(True)
font.setWeight(75)
item.setFont(font)
self.sentenceToFillTable.setHorizontalHeaderItem(0, item)
self.sentenceToFillTable.resizeColumnsToContents()
self.sentenceToFillTable.horizontalHeader().setStretchLastSection(True)
self.sentenceToFillTable.verticalHeader().setStretchLastSection(True)
self.sentenceList = []
self.getSentencesFromDatabase()
# split the sentences into chunks of 5
# Map to hold the anwers
self.rightWordList = {}
self.iteration = 0
self.sentenceMasterList = []
self.sentenceSlaveList = []
if len(self.sentenceList) > 0:
for sentence in self.sentenceList:
if len(self.sentenceSlaveList) < 5:
self.sentenceSlaveList.append(sentence)
else:
self.sentenceMasterList.append(self.sentenceSlaveList)
self.sentenceSlaveList = []
self.sentenceSlaveList.append(sentence)
if len(self.sentenceSlaveList) <= 5:
self.sentenceMasterList.append(self.sentenceSlaveList)
self.maxIteration = len(self.sentenceMasterList)
## set the row height
self.tableHeightSize = 0
## Only if there is atleast one sentence fetched from the database
if len(self.sentenceList) > 0:
for index in range(0, 5):
if len(self.sentenceList[index]) < 150:
self.sentenceToFillTable.verticalHeader().resizeSection(index, 80)
self.tableHeightSize = self.tableHeightSize + 90
elif len(self.sentenceList[index]) < 200:
self.sentenceToFillTable.verticalHeader().resizeSection(index, 100)
self.tableHeightSize = self.tableHeightSize + 100
else:
self.sentenceToFillTable.verticalHeader().resizeSection(index, 120)
self.tableHeightSize = self.tableHeightSize + 120
# split words from databse into chunks of 5
self.refIteration = 0
self.refWordMasterList = []
self.refWordSlaveList = []
for wordList in self.wordMap.values():
if len(self.refWordSlaveList) < 5:
self.refWordSlaveList.append(wordList)
else:
self.refWordMasterList.append(self.refWordSlaveList)
self.refWordSlaveList = []
self.refWordSlaveList.append(wordList)
if len(self.refWordSlaveList) <= 5:
self.refWordMasterList.append(self.refWordSlaveList)
self.refMaxIteration = len(self.refWordMasterList)
self.insertSentencesInTable()
self.connect(self.sentenceToFillTable, SIGNAL("cellClicked(int, int)"), self.itemSelect)
# create next, submit and close buttons
self.nextButton = QPushButton('Next', self)
self.nextButton.move(170, 520)
self.nextButton.setEnabled(False)
self.submitButton = QPushButton('Submit', self)
self.submitButton.move(380, 520)
self.closeButton = QPushButton('Close', self)
self.closeButton.move(600, 520)
self.connect(self.closeButton, SIGNAL('clicked()'), self.closeClicked)
self.connect(self.submitButton, SIGNAL('clicked()'), self.onSubmitClicked)
self.connect(self.nextButton, SIGNAL('clicked()'), self.onNextClicked)
self.setWindowTitle('Sentence Fill')
#self.setGeometry(10, 80, 1100, 750)
def getSentencesFromDatabase(self):
self.twoTypeList = data.Data().getSentencesFromDatabase(self.tableName, self.rangeValues)
if len(self.twoTypeList) == 2:
self.sentenceList = self.twoTypeList[0]
self.wordMap = self.twoTypeList[1]
def closeClicked(self):
reply = QMessageBox.question(self,
"Fill the Sentences",
"You want to close the application",
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
self.reject()
def onNextClicked(self):
if not self.iteration < self.maxIteration:
QMessageBox.information(self,
"Fill the Sentences",
"All Sentences are matched",
QMessageBox.Ok)
else:
self.sentenceToFillTable.clearContents()
## Fetch the next records
self.refIteration = self.refIteration + 1
self.rightWordList = {}
## clear the contents of the combo box
self.wordListComboBox.clear()
self.insertSentencesInTable()
# validate whether the user has matched the blanks with a value during next and submit button clicks
def onNextSubmitValidation(self):
self.textNotFilled = False
for row in range(0, len(self.currentSentenceListInTable)):
if self.sentenceToFillTable.item(row, 0).text() == self.currentSentenceListInTable[row]:
self.textNotFilled = True
if self.textNotFilled:
QMessageBox.information(self,
"Fill the sentences",
"Match all the sentences in the table",
QMessageBox.Ok)
self.nextButton.setEnabled(False)
def onSubmitClicked(self):
self.wordsMatched = True
self.allWordsMatched = True
brushRed = QBrush(QColor(255,0,0))
brushRed.setStyle(Qt.SolidPattern)
brushGreen = QBrush(QColor(0,255,0))
brushGreen.setStyle(Qt.SolidPattern)
# validate whether the user all matched the blanks with a value
#self.onNextSubmitValidation()
textNotFilled = False
for row in range(0, len(self.currentSentenceListInTable)):
if self.sentenceToFillTable.item(row, 0).text() == self.currentSentenceListInTable[row]:
textNotFilled = True
if textNotFilled:
QMessageBox.information(self,
"Fill the sentences",
"Match all the sentences in the table",
QMessageBox.Ok)
else:
splittedSentence = []
foundWordInSentence = ""
self.rightWordListCopy = self.rightWordList
for row in range(0, len(self.currentSentenceListInTable)):
sentenceFilled = str(self.sentenceToFillTable.item(row, 0).text())
newSplittedSentence = [word.strip() for word in sentenceFilled.split()]
splittedSentence = []
for word in newSplittedSentence:
match = re.search(r'\w+', word)
if match:
splittedSentence.append(str(match.group()))
wordList = self.rightWordListCopy[row]
if len(wordList) > 1:
firstWord = wordList[0].strip()
secondWord = wordList[1].strip()
if ' ' in firstWord:
for word in firstWord.split():
if word not in splittedSentence:
self.wordsMatched = False
else:
if firstWord not in splittedSentence:
self.wordsMatched = False
if self.wordsMatched: ## check is valid only if the first word is matched
if ' ' in secondWord:
for word in secondWord.split():
if word not in splittedSentence:
self.wordsMatched = False
else:
if secondWord not in splittedSentence:
self.wordsMatched = False
elif len(wordList) == 1:
word = wordList[0].strip()
if word not in splittedSentence:
self.wordsMatched = False
if self.wordsMatched:
self.sentenceToFillTable.item(row, 0).setBackground(brushGreen)
else:
self.sentenceToFillTable.item(row, 0).setBackground(brushRed)
self.allWordsMatched = False
self.wordsMatched = True
if self.allWordsMatched:
self.nextButton.setEnabled(True)
QMessageBox.information(self,
"Fill the sentences",
"All sentences are matched",
QMessageBox.Ok)
def insertSentencesInTable(self):
if self.iteration < self.maxIteration:
cellList = []
self.col = 0
self.currentSentenceListInTable = self.sentenceMasterList[self.iteration]
for sentence in self.currentSentenceListInTable:
item = QTableWidgetItem(QString(sentence))
item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled))
cellList.append(item)
cellList.reverse()
for index in range(0, len(self.currentSentenceListInTable)):
self.sentenceToFillTable.setItem(index, self.col, cellList.pop())
self.sentenceToFillTable.setRowCount(len(self.sentenceMasterList[self.iteration]))
self.sentenceToFillTable.setFixedHeight(self.tableHeightSize)
# increment the count for the next button click
self.iteration = self.iteration + 1
def createComboBox(self, rowIndex):
self.xAxis = 1000
self.yAxis = 80
if self.refIteration < self.refMaxIteration:
wordListWithFiveArrays = self.refWordMasterList[self.refIteration]
requiredWordList = wordListWithFiveArrays[rowIndex]
## Create a combo box
self.wordListComboBox = QComboBox(self)
self.wordListComboBox.setGeometry(900, 80, 100, 20)
self.connect(self.wordListComboBox, SIGNAL("currentIndexChanged(int)"),
self.wordSelected)
self.wordListComboBox.show()
## save the right word
if len(requiredWordList) > 0:
if rowIndex not in self.rightWordList.keys():
if len(requiredWordList) > 0:
wordList = requiredWordList[0].split('&')
self.rightWordList[rowIndex] = wordList
## insert words in the combo box
random.shuffle(requiredWordList)
random.shuffle(requiredWordList)
self.wordListComboBox.addItem(' ')
self.wordListComboBox.addItems(requiredWordList)
def wordSelected(self):
## Avoid the blank option
if len(str(self.wordListComboBox.currentText()).strip()) > 0:
sentence = self.currentSentenceListInTable[self.selectedSentenceIndex]
splittedText = sentence.split('-')
if len(splittedText) == 2:
item = QTableWidgetItem(QString(splittedText[0] +
str(self.wordListComboBox.currentText()) + ' ' + splittedText[1].strip()))
item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled))
self.sentenceToFillTable.setItem(self.selectedSentenceIndex, 0, item)
elif len(splittedText) > 2:
wordsFromCombobox = str(self.wordListComboBox.currentText()).split('&')
item = QTableWidgetItem(QString(splittedText[0] + wordsFromCombobox[0]
+ splittedText[1] + wordsFromCombobox[1] + ' ' + splittedText[2].strip()))
item.setFlags(Qt.ItemFlags(Qt.ItemIsSelectable |
Qt.ItemIsEnabled))
self.sentenceToFillTable.setItem(self.selectedSentenceIndex, 0, item)
def createIndexForWords(self):
self.indexForWords = {}
self.nextIndex = 0
for word in self.refWordListForIndex:
if self.nextIndex == 5:
break
self.indexForWords[word] = self.nextIndex
self.nextIndex = self.nextIndex + 1
def itemSelect(self,rowIndex):
self.createComboBox(rowIndex)
self.selectedSentenceIndex = rowIndex
