def loads(self, stream, fileroot):
self.wipe_slate()
design = PropertyNode()
if props_json.loads(stream, design, ""):
print "json parse successful"
else:
error = QErrorMessage(self)
error.showMessage( "json parse failed" )
return False
# design.pretty_print()
self.setWindowTitle( self.default_title + " - " + fileroot )
node = design.getChild('overview', True)
self.overview.load(node)
design.setLen('wing', 1) # force to be enumerated if not already
num_wings = design.getLen('wing')
for i in range(num_wings):
wing_node = design.getChild('wing[%d]' % i)
wing = WingUI(changefunc=self.onChange)
wing.load(wing_node)
self.wings.append(wing)
self.tabs.addTab( wing.get_widget(), "Wing: " + wing.get_name() )
self.rebuildWingLists()
self.setClean()
def handle_error(self, error):
"""Handle when an error occurs
Show the error in an error message window.
"""
em = QErrorMessage(self.main_window)
em.showMessage(error)
def validateForSubmit(self):
errorMsgs = []
reference = self.ui.referenceField.text()
if reference == "":
errorMsgs.append("Du har glömt referensfältet")
counter = 1
for j in self.jobList:
if j.ui.description.text() == "":
errorMsgs.append("Du har glömt beskrivning på job " + str(counter))
try:
float(j.ui.price.text().replace(",", "."))
except Exception:
errorMsgs.append("Det ser inte ut som en siffra på priset på job " + str(counter))
try:
int(j.ui.number.text())
except Exception:
errorMsgs.append("Det ser inte ut som en siffra på antalet på job " + str(counter))
counter += 1
# TODO: if new customer is added
if self.newCustomerActivated:
if self.newCustomerForm.ui.name.text() == "":
errorMsgs.append("Det finns inget namn på den nya kunden")
if self.newCustomerForm.ui.address.text() == "":
errorMsgs.append("Det finns ingen address på den nya kunden")
if self.newCustomerForm.ui.zip.text() == "":
errorMsgs.append("Det finns inget postnummer på den nya kunden")
if len(errorMsgs) != 0:
errWidget = QErrorMessage(self)
errWidget.showMessage("<br/>".join(errorMsgs))
return False
return True
def display_error(err):
app = QApplication.instance()
window = app.activeWindow()
dialog = QErrorMessage(window)
dialog.setWindowModality(Qt.WindowModal)
dialog.setWindowTitle("Error")
dialog.showMessage(err)
def main():
# Arguments parsing
parser = argparse.ArgumentParser(
description="Daemon program for the Optimus Manager tool.\n"
"https://github.com/Askannz/optimus-manager")
parser.parse_args()
print("Optimus Manager (systray) version %s" % envs.VERSION)
# Setup
app = QApplication(sys.argv)
# Make sure it doesn't quit after cancelling a confirm prompt
app.setQuitOnLastWindowClosed(False)
# Warning message : this app is deprecated
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setText("optimus-manager-systray is deprecated")
msg.setText(
"The current tray app bundled in optimus-manager is deprecated"
" and will be removed in a future release. Please install the program"
" <b>optimus-manager-qt</b> instead.<br><br>"
"Github : <a href=\"https://github.com/Shatur95/optimus-manager-qt\">"
"https://github.com/Shatur95/optimus-manager-qt</a><br>"
"AUR : <a href=\"https://aur.archlinux.org/packages/optimus-manager-qt/\">"
"https://aur.archlinux.org/packages/optimus-manager-qt/</a><br>")
msg.exec()
# Check current mode
try:
mode = checks.read_gpu_mode()
print('Current mode:', mode)
except checks.CheckError as e:
msg = "Error reading mode : %s" % str(e)
print(msg)
error_dialog = QErrorMessage()
error_dialog.showMessage(msg)
sys.exit(app.exec_())
# Setup systray
widget = QWidget()
tray_icon = SystemTrayIcon(mode, widget)
tray_icon.show()
# Make sure KeyboardInterrupt signals and exceptions are handled correctly
setup_interrupt_handling()
sys.excepthook = traceback.print_exception
# Start
sys.exit(app.exec_())
def save_comments(self):
if self.current_mode is None:
self.error_dialog = QErrorMessage()
self.error_dialog.showMessage("No mode selected")
return
file = self.expListWidget.currentItem().data(QtCore.Qt.UserRole)
fname = file[:-3]
label = DataLabel(opt1=self.opt1.text(),
opt2=self.opt2.text(),
comments=self.commentLineEdit.text(),
error=self.errorCheckBox.isChecked(),
mode=self.current_mode)
label.save(fname)
def connection_error(self, error):
self.timer.stop()
error_dialog = QErrorMessage()
error_dialog.setWindowTitle('Unable to connect to discord')
error_dialog.showMessage(error)
error_dialog.exec_()
sys.exit(1)
def readContours(self):
"""Reads contours saved in xml format (Echoplaque compatible)"""
if self.image == False:
warning = QErrorMessage()
warning.setWindowModality(Qt.WindowModal)
warning.showMessage(
'Reading of contours failed. Images must be loaded prior to loading contours'
)
warning.exec_()
else:
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(
self,
"QFileDialog.getOpenFileName()",
"",
"XML file (*.xml)",
options=options)
self.lumen, self.plaque, self.stent, self.resolution, frames = read_xml.read(
fileName)
self.lumen = self.mapToList(self.lumen)
self.plaque = self.mapToList(self.plaque)
self.stent = self.mapToList(self.stent)
self.contours = True
self.resizeContours()
self.wid.setData(self.lumen, self.plaque, self.images)
self.hideBox.setChecked(False)
def go_to_epoch(self, checked=False, test_text_str=None):
"""Go to any window"""
if test_text_str is not None:
time_str = test_text_str
ok = True
else:
time_str, ok = QInputDialog.getText(self,
'Go To Epoch',
'Enter start time of the '
'epoch,\nin seconds ("1560") '
'or\nas absolute time '
'("22:30")')
if not ok:
return
try:
rec_start_time = self.parent.info.dataset.header['start_time']
window_start = _convert_timestr_to_seconds(time_str, rec_start_time)
except ValueError as err:
error_dialog = QErrorMessage()
error_dialog.setWindowTitle('Error moving to epoch')
error_dialog.showMessage(str(err))
if test_text_str is None:
error_dialog.exec()
self.parent.statusBar().showMessage(str(err))
return
self.parent.overview.update_position(window_start)
class MainWindow(QMainWindow, DatalogTestItemAnalysis_UI.Ui_MainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.cwd = getcwd()
self.qe = QErrorMessage(self)
self.Open_pushButton.clicked.connect(self.Open)
self.Run_pushButton.clicked.connect(self.Run)
def Open(self):
fileNameChoose, fileType = QFileDialog.getOpenFileName(
self, 'Select CSV File', self.cwd,
'CSV Files(*.csv);;All Files(*)')
if not fileNameChoose:
return
self.Open_lineEdit.setText(fileNameChoose)
def CallBackLog(self, msg):
self.progressBar.setValue(
int(msg)) # pass the thread's parameters to progressBar
if msg == '100':
self.Run_pushButton.setEnabled(True)
def Run(self):
if not self.Open_lineEdit.text():
self.qe.showMessage('Path cannot be empty!')
return
global totalCount, currentCount, last_test_item_column_num, sigma, dpi
with open(self.Open_lineEdit.text()) as f:
data = []
csvReader = reader(f)
for row in csvReader:
data.append(row)
# get row and column of last test item
search_last_test_item = search_string(data, 'MIPIError')
if not search_last_test_item:
exit()
else:
last_test_item_column_num = search_last_test_item[1]
totalCount = last_test_item_column_num
currentCount = 0
sigma = int(self.Sigma_lineEdit.text())
dpi = int(self.DPI_lineEdit.text())
# create thread
self.Run_pushButton.setEnabled(False)
self.thread = RunThread(self.Open_lineEdit.text())
# connect signal
self.thread._signal.connect(self.CallBackLog)
self.thread.daemon = True
self.thread.start()
def load_cam(self):
self.cam_page.setLayout(self.cam_page_lay)
self.error_cam.hide()
self.camera = QCameraInfo.defaultCamera()
# Проверяем, что камера сущетсвует
# Если нет, то переключаемся на вторую вкладку
if self.camera.isNull():
dialog = QErrorMessage()
dialog.setWindowTitle('Warning')
dialog.showMessage(
'Not enough cameras, the app will only be available in drawing mode'
)
dialog.exec()
self.error_cam.show()
self.cam_page.setEnabled(False)
self.tabWidget.setCurrentIndex(1)
# Если да, то на первую
else:
self.tabWidget.setCurrentIndex(0)
self.camera = QCamera(self.camera)
self.view_cam = QCameraViewfinder(self)
self.view_cam.setMediaObject(self.camera)
self.view_cam.setAutoFillBackground(True)
self.camera.setViewfinder(self.view_cam)
self.box_lay = QVBoxLayout(self)
self.box_lay.addWidget(self.view_cam)
self.scrolling.setLayout(self.box_lay)
# Запускаем камеру
self.camera.start()
# Подвязываем кнопку к слоту со снимком
self.bt_cam.clicked.connect(self.make_ph)
# Можно зумить фотографию
self.zoom.valueChanged.connect(self.zoom_pict)
def extract(self):
text = self.input_file_to_text()
user_vocab = None
if (text is None):
error = QErrorMessage(self)
error.showMessage('Please specify valid source file')
return
if (self.ui.vocabCheckBox.isChecked()):
user_vocab = self.vocab_file_to_set()
if (user_vocab is None):
error = QErrorMessage(self)
error.showMessage('Please specify valid User Vocabulary file')
return
pair = self.before_extract()
if pair is None:
return
filename = pair[0]
write_chunks = pair[1]
# with futures.ProcessPoolExecutor(1) as executor:
# vocab_future = executor.submit(extract_worker, text, user_vocab,
# filename, write_chunks)
# vocab_future.add_done_callback(self.after_extract)
vocab_future = self.ppool.submit(extract_worker, text, user_vocab,
filename, write_chunks)
vocab_future.add_done_callback(self.after_extract)
logging.debug('returning from extract')
def add_plan(self):
"""Функция, которая добавляет новые планы"""
if self.current_plan.text() == '':
self.error_dialog = QErrorMessage()
self.error_dialog.showMessage('Вам нужно обязательно ввести что-нибудь в поле.')
self.error_dialog.show()
return
else:
plan_text = self.current_plan.text()
cursor.execute(f"INSERT INTO plans VALUES (?, ?)", (user_id, plan_text))
data_base.commit()
self.list_of_plans.append(self.current_plan.text())
self.display_plans()
self.current_plan.setText('')
def showresult(self, edit1, edit2, edit3, edit4, edit5, edit6):
self.i1 = int(self.edit1.text())
self.i2 = int(self.edit2.text())
if self.i2 == 0:
self.error_dialog = QErrorMessage()
self.error_dialog.showMessage('О нет! Деление на ноль!')
else:
self.i3 = self.i1 + self.i2
self.i5 = self.i1 - self.i2
self.i4 = self.i1 * self.i2
self.i6 = self.i1 / self.i2
self.edit3.setText(str(self.i3))
self.edit4.setText(str(self.i4))
self.edit5.setText(str(self.i5))
self.edit6.setText(str(self.i6))
def segment(self):
"""Segmentation and phenotyping of IVUS images"""
warning = QErrorMessage()
warning.setWindowModality(Qt.WindowModal)
warning.showMessage(
'Warning: IVUS Phenotyping is currently only supported for 20MHz images. Interpret other images with extreme caution'
)
warning.exec_()
def au(self, acc, paw):
u = UserManage()
u.addUser(acc, paw)
er = QErrorMessage(self)
er.setWindowTitle("提示")
er.showMessage("添加成功！")
er.show()
self.showAll()
def startMultiplayerTournament(self):
self.playerNames = self.tournamentMenuMapper.mapOnlyNames(
self.multiplayerTournamentScene)
if self.playerNames is None:
error_dialog = QErrorMessage()
error_dialog.showMessage(
"All IDs must differ from each other and cannot be empty.")
else:
self.view = QtWidgets.QGraphicsView(self.scene)
self.view.setSceneRect(90, 90, 1250, 738)
self.view.setViewportUpdateMode(
QtWidgets.QGraphicsView.NoViewportUpdate)
self.view.setInteractive(False)
self.setCentralWidget(self.view)
self.tm = TournamentManager.Tournament(self.playerNames)
def export_raw(self):
if not self.ctx.get_status(): return
fname, scheme = QFileDialog.getSaveFileName(
self.win, 'Export People Data to CSV', None,
"Comma-separated Values Files (*.csv)")
if not fname: return
if not fname.endswith('.csv'):
fname += '.csv'
try:
with open(fname, 'w') as handle:
self.ctx.app_data_manager.export_raw_to_csv(handle)
handle.close()
except Exception as e:
error_dialog = QErrorMessage()
error_dialog.showMessage(str(e))
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.cwd = getcwd()
self.qe = QErrorMessage(self)
self.pale = QPalette()
# self.pale.setBrush(self.backgroundRole(), QBrush(QPixmap('./images/kobe3.jpg')))
self.setPalette(self.pale)
self.Open_pushButton.clicked.connect(self.Open)
self.Project_comboBox.insertItem(0, self.tr('F28'))
self.Project_comboBox.insertItem(1, self.tr('JX825'))
self.Project_comboBox.insertItem(2, self.tr('JX828'))
self.Project_comboBox.insertItem(3, self.tr('JX829'))
self.Project_comboBox.insertItem(4, self.tr('JX832'))
self.Analysis_pushButton.clicked.connect(self.Analysis)
def readAllSerial(self, returnOutput=False, printOutput=True):
if self.serial.is_open:
returnString = str(self.serial.read(
self.serial.inWaiting())).strip("'").strip("b'")
if printOutput:
print(returnString)
# In case of an error from the arduino:
if returnString[:5] == "ERROR:"[:5]:
errorMessage = QErrorMessage()
errorMessage.showMessage(returnString)
if returnOutput:
return returnString
def delete_page(self):
# предупреждение о тонкостях удаления страниц
if self.count != self.maxcount:
dop = 'Удалится не текущая страница, а последняя. \n \t Продолжить?'
else:
dop = 'Удалить страницу?'
reply = QMessageBox.question(self, 'Удаление страницы', dop,
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
# в случае положительного ответа
if reply == QMessageBox.Yes:
# проверка, что не удаляется единственная страница, а если удаляется, выводится ошибка
if self.maxcount == 1:
error = QErrorMessage(self)
error.showMessage(
'Ошибка. Осталась всего одна страница. Ее нельзя удалять')
return
# в файле последней страницы удаляется все содержимое
with open("{}.txt".format(self.maxcount), 'w') as f:
f.write('')
# если пользователь находился на последней странице, а ее удаляют, он переместится на
# предыдущую, а если нет, то останется на прежней
if self.count == self.maxcount:
self.count -= 1
self.maxcount -= 1
with open("{}.txt".format(self.maxcount)) as f:
self.note.setText(f.read())
self.count_page.display(self.count)
self.count_page_max.display(self.count)
else:
self.maxcount -= 1
self.count_page.display(self.count)
self.count_page_max.display(self.maxcount)
with open("page.txt", 'w') as f:
f.write(str(self.maxcount))
# установка активности кнопок
if self.maxcount == 1:
self.button_left_page.setEnabled(False)
self.button_right_page.setEnabled(False)
elif self.count == 1:
self.button_left_page.setEnabled(False)
self.button_right_page.setEnabled(True)
elif self.count == self.maxcount:
self.button_left_page.setEnabled(True)
self.button_right_page.setEnabled(False)
else:
self.button_left_page.setEnabled(True)
self.button_right_page.setEnabled(True)
def connect_to_laser(self):
logging.info("Looking for COM ports")
available_comports = list(serial.tools.list_ports.comports())
self.ui.comboBox.clear()
for port in available_comports:
self.ui.comboBox.addItem(port.device)
self.display_repetition_quantity = True
self.display_repetition_frequency = True
self.last_transmitted_quantity = -1.0
self.last_transmitted_frequency = -1.0
self.ui.connection_label.setText("Connecting to laser...")
self.app.processEvents()
try:
self.laser_communication_thread = laser_communication.LaserCommunicationThread(
self, debug=False)
logging.info("Connecting GUI signals")
self.ui.stop_button.clicked.connect(
self.laser_communication_thread.Stop)
self.ui.burst_on_button.clicked.connect(
self.laser_communication_thread.BurstOn)
self.ui.laser_off_button.clicked.connect(
self.laser_communication_thread.LaserOff)
self.ui.standby_button.clicked.connect(
self.laser_communication_thread.LaserOn)
self.ui.toggle_shutter_button.clicked.connect(
self.laser_communication_thread.ToggleShutter)
self.ui.external_trigger_on_button.clicked.connect(
self.laser_communication_thread.ExternalTriggerOn)
self.ui.repetition_on_button.clicked.connect(
self.laser_communication_thread.RepetitionOn)
self.ui.repetition_rate_spinBox.editingFinished.connect(
self.repetition_rate_changed)
self.set_repetition_rate_signal.connect(
self.laser_communication_thread.setRepetitionRate)
self.ui.repetition_quantity_spinBox.editingFinished.connect(
self.repetition_quantity_changed)
self.set_repetition_quantity_signal.connect(
self.laser_communication_thread.setRepetitionQuantity)
logging.info("Starting laser communication thread.")
self.laser_communication_thread.start()
except Exception as e:
self.error_window = QErrorMessage(self)
self.error_window.message = str(e)
def searchF(self, state):
@pyqtSlot(list)
def Users(users):
#print(users)
self.model_list.items.clear()
for u in users:
self.model_list.items.append(u)
self.model_list.layoutChanged.emit()
f = dict()
for k in self.model_table.item.keys():
if self.model_table.item.get(k) != user().get(k) or k in [
'page', 'limit'
]:
f[k] = self.model_table.item.get(k)
searchUsers = SearchUser(self.auth, f)
#print(f,"searchF "*10)
searchUsers.signals.finished.connect(
lambda: print("finished searchUser"))
searchUsers.signals.hasError.connect(lambda x: QErrorMessage(
self.parent).showMessage(str(x) + __name__))
searchUsers.signals.hasResponse.connect(lambda x: print(x, "response"))
searchUsers.signals.hasUsers.connect(Users)
QThreadPool.globalInstance().start(searchUsers)
def process(self):
search_name = self.searchName.text()
layer = self.layerCombo.currentLayer()
expression = self.fieldExpressionWidget.currentField()[0]
priority = self.priorityBox.value()
srid = layer.crs().authid()
evaluate_directly = self.evaluateCheckBox.isChecked()
if self.projectSearch is None:
self.projectSearch = self.project_search_model.addSearch(search_name, layer, expression, priority)
else:
self.projectSearch.edit(search_name, layer.id(), layer.name(), expression, priority, srid)
if evaluate_directly:
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(layer.featureCount())
self.progressBar.show()
self.cancelButton.show()
ok, message = self.project_finder.recordSearch(self.projectSearch)
self.progressBar.hide()
self.cancelButton.hide()
self.okButton.show()
if not ok:
QErrorMessage().showMessage(message)
return
self.close()
def save(self,state):
#print(self.model.item)
self.saveUser=SaveUser(self.auth,self.model.item)
self.saveUser.signals.finished.connect(lambda :print("user finished saving"))
self.saveUser.signals.hasError.connect(lambda x:QErrorMessage(self.parent).showMessage(str(x)+__name__))
self.saveUser.signals.hasResponse.connect(lambda x:print(x))
QThreadPool.globalInstance().start(self.saveUser)
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.openFilesPath = ''
self.errorMessageDialog = QErrorMessage(self)
frameStyle = QFrame.Sunken | QFrame.Panel
self.textLabel = QLabel()
self.textLabel.setFrameStyle(frameStyle)
self.textButton = QPushButton("Press")
self.warningLabel = QLabel()
self.warningLabel.setFrameStyle(frameStyle)
self.warningButton = QPushButton("Autor")
self.textButton.clicked.connect(self.setText)
self.warningButton.clicked.connect(self.warningMessage)
self.native = QCheckBox()
self.native.setText("Use native file dialog.")
self.native.setChecked(True)
if sys.platform not in ("win32", "darwin"):
self.native.hide()
layout = QGridLayout()
layout.setColumnStretch(1, 1)
layout.setColumnMinimumWidth(1, 250)
layout.addWidget(self.textButton, 3, 0)
layout.addWidget(self.textLabel, 3, 1)
self.setLayout(layout)
self.setWindowTitle("3b")
def run(self):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
transform_svds(self.ris_files,
self.rois,
self.QComboBox_scaling.currentText(),
self.output_directory)
QApplication.restoreOverrideCursor()
self.QMessageBox_finnish = QMessageBox()
self.QMessageBox_finnish.setWindowTitle("Finished")
self.QMessageBox_finnish.setText("Done.")
self.QMessageBox_finnish.exec_()
except Exception as e:
QApplication.restoreOverrideCursor()
self.QErrorMessage = QErrorMessage()
self.QErrorMessage.showMessage(str(e))
def generateTriangles(self):
self.fill = {}
for idx, vert in enumerate(self.vertecies):
if self.checkIntersection(vert):
box = QErrorMessage(self)
box.showMessage("Intersection in one curve is not supported!")
return False
#cdt = CDT(vert[:-2]) # do not add last point again, poly2tri #cdt
#= CDT(vert[:-2]) # do not add last point again, poly2tri
#crashes if there is the same point
#crashes if there is the same point
# twice
#cdt.triangulate()
#self.fill[idx] = cdt.get_triangles()
self.update()
return True
def aboutconfig(self):
self.aboutconfigVar=readAbout(Path("Client/MainWindow/about.json"))
#not this one
self.aboutconfigVar.signals.hasError.connect(lambda x:QErrorMessage(self.parent).showMessage(str(x)+__name__))
self.aboutconfigVar.signals.hasAbout.connect(self.icon)
self.aboutconfigVar.signals.finished.connect(lambda : print("reading about config"))
QThreadPool.globalInstance().start(self.aboutconfigVar)
def export_results_select(self):
if not self.ctx.app_data.results: return
fname, scheme = QFileDialog.getSaveFileName(
self.win, 'Export Allocation to CSV', None,
"Comma-separated Values Files (*.csv)")
if not fname: return
if not fname.endswith('.csv'):
fname += '.csv'
try:
with open(fname, 'w') as handle:
a = self.ctx.window.tabs.tab_results.tabs.currentIndex()
self.ctx.app_data_manager.export_allocation_to_csv(handle, a)
handle.close()
except Exception as e:
error_dialog = QErrorMessage()
error_dialog.showMessage(str(e))
def __init__(self, reference_item):
CustomStandardDialog.__init__(self)
self.setupUi(self)
# Save the input reference item to detect changes
self.reference_item = reference_item
# Initialize a error dialog that is fed by the workers
self.error_dialog = QErrorMessage(self)
# Setup threads and worker objects for retrieval of data
# from NCBI. Use one thread for the pubmed lookup.
self.pmid_thread = QtCore.QThread(self)
self.pmid_worker = RetrievePubmedData()
self.pmid_worker.moveToThread(self.pmid_thread)
# Use a second thread for the querying of non pubmed ids
# like DOIs or Pubmed central Ids. Those Ids are translated
# to pubmed ids in order to not implement a second parser
# for the pubmed central xml format
self.id_thread = QtCore.QThread(self)
self.id_worker = IdConverter()
self.id_worker.moveToThread(self.id_thread)
self.connect_workers()
# Setup the author table data model
self.authorTable = AuthorTable(self)
self.authorTableView.setModel(self.authorTable)
# Setup items, disable Ok button and restore state
self.populate_inputs()
self.buttonBox.button(QDialogButtonBox.Save).setEnabled(False)
self.setup_connections()
self.restore_dialog_geometry()
def use_filter(self, func):
if self.flag_open:
pil_image = Image.open(self.filename)
try:
try:
args = map(lambda x: x[1], list(self.func_dict[func.__name__].items()))
pil_image = func(pil_image, *args)
except KeyError:
pil_image = func(pil_image)
except:
QErrorMessage(self).showMessage("Bad filter!")
return
# ***************** переделать через буфер *****************
# PIL.Image.Image -> QImage
pil_image.save("PIL_tmp.jpg")
image = QImage("PIL_tmp.jpg")
item = QGraphicsPixmapItem(QPixmap.fromImage(image))
self.graphicsView.scene().items().clear()
self.graphicsView.scene().addItem(item)
self.graphicsView.show()
if not self.windowTitle().endswith(' *'):
self.setWindowTitle(self.windowTitle() + ' *')
self.flag_save = True
def save_dynamic(self):
from db_manag import DBmanager
from sqlite3 import OperationalError as sqlite3_OperationalError
self.data_base = DBmanager(self.settings_way_db, 'valute')
try: self.data_base.insert_into_table_dynamic_rate(self.dynamic_req)
except sqlite3_OperationalError:
self.data_base.create_table_dynamic_rate()
self.data_base.insert_into_table_dynamic_rate(self.dynamic_req)
self.message_save_data = QMessageBox.information(self, 'Save Data', 'Data saved',
QMessageBox.Ok)
except AttributeError:
self.error_no_data = QErrorMessage(self)
self.error_no_data.setWindowTitle('No data')
self.error_no_data.showMessage('No data to save')
else: self.message_save_data = QMessageBox.information(self, 'Save Data', 'Data saved',
QMessageBox.Ok)
def setPropertyForAllObjects(self):
selectedPropertyIndices = self.selectedColumns() if self.model().isRowObjects else self.selectedRows()
if len(selectedPropertyIndices) != 1:
errorDialog = QErrorMessage(self)
rowOrColumn = "column" if self.model().isRowObjects else "row"
errorDialog.showMessage("Must select a single property " + rowOrColumn + ".")
errorDialog.exec_()
return
try:
propertyIndex = selectedPropertyIndices[0]
dtype = self.model().propertyType(propertyIndex)
if dtype is None:
return
obj = self.model().objects[0]
prop = self.model().properties[propertyIndex]
if "Write" not in prop.get('mode', "Read/Write"):
return
model = ObjectListTableModelQt([obj], [prop], self.model().isRowObjects, False)
view = ObjectListTableViewQt(model)
dialog = QDialog(self)
buttons = QDialogButtonBox(QDialogButtonBox.Ok)
buttons.accepted.connect(dialog.accept)
buttons.rejected.connect(dialog.reject)
vbox = QVBoxLayout(dialog)
vbox.addWidget(view)
vbox.addWidget(buttons)
dialog.setWindowModality(Qt.WindowModal)
dialog.exec_()
for objectIndex, obj in enumerate(self.model().objects):
row = objectIndex if self.model().isRowObjects else propertyIndex
col = propertyIndex if self.model().isRowObjects else objectIndex
index = self.model().index(row, col)
if objectIndex == 0:
value = self.model().data(index)
else:
if prop.get('action', '') == "fileDialog":
try:
getAttrRecursive(obj, prop['attr'])(value)
self.model().dataChanged.emit(index, index) # Tell model to update cell display.
except:
self.model().setData(index, value)
self.model().dataChanged.emit(index, index) # Tell model to update cell display.
else:
self.model().setData(index, value)
self.model().dataChanged.emit(index, index) # Tell model to update cell display.
except:
pass
def start(mode):
# Install message handler for Qt messages
qInstallMessageHandler(gui_msg_handler)
# Start the Qt main object
app = QApplication([])
# Start the bluesky network client
client = GuiClient()
# Enable HiDPI support (Qt5 only)
if QT_VERSION >= 0x050000:
app.setAttribute(Qt.AA_UseHighDpiPixmaps)
splash = Splash()
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMCUSTOMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print(('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype)))
splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print(('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion())))
splash.showMessage('Constructing main window')
app.processEvents()
win = MainWindow(mode)
win.show()
splash.showMessage('Done!')
app.processEvents()
splash.finish(win)
# If this instance of the gui is started in client-only mode, show
# server selection dialog
if mode == 'client':
dialog = DiscoveryDialog(win)
dialog.show()
bs.net.start_discovery()
else:
client.connect(event_port=bs.settings.event_port,
stream_port=bs.settings.stream_port)
# Start the Qt main loop
app.exec_()
def scan_start(self, event=None):
if pathlib.Path(self.filename()).is_dir():
err = QErrorMessage(self)
err.setWindowTitle("eDocuments - Error")
err.showMessage("The destination is a directory!")
return
destination1, extension, _, _ = self.backend.process.destination_filename(
self.ui.scan_type.currentData().get("cmds"),
self.filename()
)
destination2, extension, _, _ = self.backend.process.destination_filename(
self.ui.scan_type.currentData().get("postprocess", {}),
destination1
)
if pathlib.Path(destination1).is_file() or pathlib.Path(destination2).is_file():
msg = QMessageBox(self)
msg.setWindowTitle("Scanning...")
msg.setText("The destination file already exists")
msg.setInformativeText("Do you want to overwrite it?")
msg.setStandardButtons(
QMessageBox.Ok | QMessageBox.Cancel | QMessageBox.Open)
ret = msg.exec()
if ret == QMessageBox.Ok:
if pathlib.Path(destination1).is_file():
os.unlink(destination1)
if pathlib.Path(destination2).is_file():
os.unlink(destination2)
self._scan()
elif ret == QMessageBox.Open:
if pathlib.Path(destination1).is_file():
cmd = edocuments.config.get('open_cmd').split(' ')
cmd.append(destination1)
call(cmd)
if pathlib.Path(destination2).is_file():
cmd = edocuments.config.get('open_cmd').split(' ')
cmd.append(destination2)
call(cmd)
else:
self._scan()
def __init__(self, args):
super().__init__(args)
self.error_msg = QErrorMessage()
self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
signal.signal(signal.SIGINT, self.exit_demo)
signal.signal(signal.SIGTERM, self.exit_demo)
self.make_gui()
self.connect()
def __init__(self, args):
super().__init__(args)
self.error_msg = QErrorMessage()
self.ipcon = IPConnection()
signal.signal(signal.SIGINT, self.exit_demo)
signal.signal(signal.SIGTERM, self.exit_demo)
timer = QTimer(self)
timer.setSingleShot(True)
timer.timeout.connect(self.connect)
timer.start(1)
def __init__(self, videoWidget, subtitleData, parent=None):
super().__init__(parent)
self._models = defaultdict(self._modelFactory) # path : QStandardItemModel
self._current = None
self._videoWidget = videoWidget
self._subtitleData = subtitleData
# avoid unnecessary copies in each addPoint() call
self._err = QErrorMessage()
self._table = None
self._subtitleData.fileChanged.connect(self._fileChanged)
self._subtitleData.subtitlesChanged.connect(self._subtitlesChanged)
self._subtitleData.subtitlesAdded.connect(self._subtitlesAdded)
self._subtitleData.subtitlesRemoved.connect(self._subtitlesRemoved)
def __init__(self):
super(Gui, self).__init__([])
self.acdata = ACDataEvent()
self.routedata = RouteDataEvent()
self.navdb = None
self.radarwidget = []
self.command_history = []
self.cmd = ''
self.args = []
self.history_pos = 0
self.command_mem = ''
self.command_line = ''
self.prev_cmdline = ''
self.mousedragged = False
self.mousepos = (0, 0)
self.prevmousepos = (0, 0)
self.panzoomchanged = False
self.simt = 0.0
# Register our custom pan/zoom event
for etype in range(1000, 1000 + NUMEVENTS):
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype))
self.splash = Splash()
self.splash.show()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion()))
# Enable HiDPI support (Qt5 only)
if QT_VERSION == 5:
self.setAttribute(Qt.AA_UseHighDpiPixmaps)
def __init__(self, parent, app):
super().__init__()
self.app = app
self.setupUi(self)
self.error_msg = QErrorMessage()
self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
self.slider_frame_rate.valueChanged.connect(self.slider_frame_rate_changed)
self.spinbox_frame_rate.valueChanged.connect(self.spinbox_frame_rate_changed)
self.button_choose.pressed.connect(self.choose_pressed)
self.button_show.pressed.connect(self.show_pressed)
self.button_default.pressed.connect(self.default_pressed)
self.update_frame_rate_timer = QTimer(self)
self.update_frame_rate_timer.timeout.connect(self.update_frame_rate)
self.default_pressed()
def __init__(self) :
#заглушка
qem = QErrorMessage()
qem.showMessage('Не удаётся подключиться к Raspberry Pi: Будет подключена локальная камера')
qem.exec()
self._capturedDevice = cv2.VideoCapture(0)
class ImagesWidget(QWidget, Ui_Images):
images = None
def __init__(self, parent, app):
super().__init__()
self.app = app
self.setupUi(self)
self.error_msg = QErrorMessage()
self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
self.slider_frame_rate.valueChanged.connect(self.slider_frame_rate_changed)
self.spinbox_frame_rate.valueChanged.connect(self.spinbox_frame_rate_changed)
self.button_choose.pressed.connect(self.choose_pressed)
self.button_show.pressed.connect(self.show_pressed)
self.button_default.pressed.connect(self.default_pressed)
self.update_frame_rate_timer = QTimer(self)
self.update_frame_rate_timer.timeout.connect(self.update_frame_rate)
self.default_pressed()
def start(self):
self.images = Images(self.app.ipcon)
self.update_frame_rate()
self.images.frame_rendered(0)
def stop(self):
if self.images:
self.images.stop_rendering()
self.images = None
def spinbox_frame_rate_changed(self, frame_rate):
self.slider_frame_rate.setValue(frame_rate)
self.update_frame_rate_timer.start(100)
def slider_frame_rate_changed(self, frame_rate):
self.spinbox_frame_rate.setValue(frame_rate)
def show_pressed(self):
if self.images:
files = self.text_edit_files.toPlainText().strip()
if len(files) > 0:
new_images = files.split('\n')
try:
self.images.set_new_images(new_images)
except Exception as e:
self.error_msg.showMessage(str(e))
self.images.frame_prepare_next()
self.images.frame_rendered(0)
def choose_pressed(self):
names, selected_filter = QFileDialog.getOpenFileNames(self, 'Choose Images', QDir.homePath())
for filename in names:
self.text_edit_files.append(filename)
def default_pressed(self):
self.spinbox_frame_rate.setValue(1)
def update_frame_rate(self):
self.update_frame_rate_timer.stop()
config.IMAGES_FRAME_RATE = self.spinbox_frame_rate.value()
if self.images:
self.images.update_frame_rate()
class Blinkenlights(QApplication):
HOST = "localhost"
PORT = 4223
ipcon = None
projects = []
active_project = None
error_msg = None
def __init__(self, args):
super().__init__(args)
self.error_msg = QErrorMessage()
self.error_msg.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
signal.signal(signal.SIGINT, self.exit_demo)
signal.signal(signal.SIGTERM, self.exit_demo)
self.make_gui()
self.connect()
def exit_demo(self, signl=None, frme=None):
try:
self.ipcon.disconnect()
self.timer.stop()
self.tabs.destroy()
except:
pass
sys.exit()
def make_gui(self):
self.main = MainWindow(self)
self.main.setWindowIcon(QIcon(load_pixmap('starter_kit_blinkenlights_demo-icon.png')))
self.tabs = QTabWidget()
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.tabs)
widget.setLayout(layout)
self.main.setCentralWidget(widget)
self.setup = SetupWidget(self.tabs, self)
self.tetris = TetrisWidget(self.tabs, self)
self.pong = PongWidget(self.tabs, self)
self.fire = FireWidget(self.tabs, self)
self.text = TextWidget(self.tabs, self)
self.images = ImagesWidget(self.tabs, self)
self.rainbow = RainbowWidget(self.tabs, self)
self.projects.append(self.setup)
self.projects.append(self.tetris)
self.projects.append(self.pong)
self.projects.append(self.fire)
self.projects.append(self.text)
self.projects.append(self.images)
self.projects.append(self.rainbow)
self.tabs.addTab(self.setup, "Setup")
self.tabs.addTab(self.tetris, "Tetris")
self.tabs.addTab(self.pong, "Pong")
self.tabs.addTab(self.fire, "Fire")
self.tabs.addTab(self.text, "Text")
self.tabs.addTab(self.images, "Images")
self.tabs.addTab(self.rainbow, "Rainbow")
self.active_project = self.projects[0]
self.tabs.currentChanged.connect(self.tab_changed_slot)
self.main.setWindowTitle("Starter Kit: Blinkenlights Demo " + config.DEMO_VERSION)
self.main.show()
def connect(self):
config.UID_LED_STRIP_BRICKLET = None
self.setup.label_led_strip_found.setText('No')
self.setup.label_led_strip_uid.setText('None')
config.UID_MULTI_TOUCH_BRICKLET = None
self.setup.label_multi_touch_found.setText('No')
self.setup.label_multi_touch_uid.setText('None')
config.UID_DUAL_BUTTON_BRICKLET = (None, None)
self.setup.label_dual_button1_found.setText('No')
self.setup.label_dual_button1_uid.setText('None')
self.setup.label_dual_button2_found.setText('No')
self.setup.label_dual_button2_uid.setText('None')
config.UID_PIEZO_SPEAKER_BRICKLET = None
self.setup.label_piezo_speaker_found.setText('No')
self.setup.label_piezo_speaker_uid.setText('None')
config.UID_SEGMENT_DISPLAY_4X7_BRICKLET = None
self.setup.label_segment_display_found.setText('No')
self.setup.label_segment_display_uid.setText('None')
if self.ipcon != None:
try:
self.ipcon.disconnect()
except:
pass
self.ipcon = IPConnection()
host = self.setup.edit_host.text()
port = self.setup.spinbox_port.value()
try:
self.ipcon.connect(host, port)
except Error as e:
self.error_msg.showMessage('Connection Error: ' + str(e.description) + "<br><br>Brickd installed and running?")
return
except socket.error as e:
self.error_msg.showMessage('Socket error: ' + str(e) + "<br><br>Brickd installed and running?")
return
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
# Wait for a second to give user visual feedback
timer = QTimer(self)
timer.setSingleShot(True)
timer.timeout.connect(self.ipcon.enumerate)
timer.start(250)
def tab_changed_slot(self, tabIndex):
self.active_project.stop()
self.active_project = self.projects[tabIndex]
self.active_project.start()
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
if device_identifier == LEDStrip.DEVICE_IDENTIFIER or device_identifier == LEDStripV2.DEVICE_IDENTIFIER:
if device_identifier == LEDStripV2.DEVICE_IDENTIFIER:
self.setup.label_7.setText('LED Strip V2')
config.IS_LED_STRIP_V2 = True
else:
self.setup.label_7.setText('LED Strip')
config.IS_LED_STRIP_V2 = False
config.UID_LED_STRIP_BRICKLET = uid
self.setup.label_led_strip_found.setText('Yes')
self.setup.label_led_strip_uid.setText(uid)
elif device_identifier == MultiTouch.DEVICE_IDENTIFIER:
config.UID_MULTI_TOUCH_BRICKLET = uid
self.setup.label_multi_touch_found.setText('Yes')
self.setup.label_multi_touch_uid.setText(uid)
elif device_identifier == DualButton.DEVICE_IDENTIFIER:
if config.UID_DUAL_BUTTON_BRICKLET[0] == None:
config.UID_DUAL_BUTTON_BRICKLET = (uid, None)
self.setup.label_dual_button1_found.setText('Yes')
self.setup.label_dual_button1_uid.setText(uid)
else:
config.UID_DUAL_BUTTON_BRICKLET = (config.UID_DUAL_BUTTON_BRICKLET[0], uid)
self.setup.label_dual_button2_found.setText('Yes')
self.setup.label_dual_button2_uid.setText(uid)
elif device_identifier == PiezoSpeaker.DEVICE_IDENTIFIER:
config.UID_PIEZO_SPEAKER_BRICKLET = uid
self.setup.label_piezo_speaker_found.setText('Yes')
self.setup.label_piezo_speaker_uid.setText(uid)
elif device_identifier == SegmentDisplay4x7.DEVICE_IDENTIFIER:
config.UID_SEGMENT_DISPLAY_4X7_BRICKLET = uid
self.setup.label_segment_display_found.setText('Yes')
self.setup.label_segment_display_uid.setText(uid)
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
self.error_msg.showMessage('Enumerate Error: ' + str(e.description))
time.sleep(1)
class Stepper(PluginBase, Ui_Stepper):
qtcb_position_reached = pyqtSignal(int)
qtcb_under_voltage = pyqtSignal(int)
def __init__(self, *args):
PluginBase.__init__(self, BrickStepper, *args)
self.setupUi(self)
self.stepper = self.device
# the firmware version of a Brick can (under common circumstances) not
# change during the lifetime of a Brick plugin. therefore, it's okay to
# make final decisions based on it here
self.has_status_led = self.firmware_version >= (2, 3, 1)
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.decay_widget.hide()
self.setting_sync_rect_checkbox = False
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.decay_syncer = SliderSpinSyncer(self.decay_slider,
self.decay_spin,
self.decay_changed)
self.enable_checkbox.toggled.connect(self.enable_toggled)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked)
self.sync_rect_checkbox.toggled.connect(self.sync_rect_toggled)
self.mode_dropbox.currentIndexChanged.connect(self.mode_changed)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.stepper.register_callback(self.stepper.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.stepper.register_callback(self.stepper.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
if self.has_status_led:
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(lambda checked: self.stepper.enable_status_led() if checked else self.stepper.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
else:
self.status_led_action = None
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.stepper.reset())
self.set_actions([(0, None, [reset])])
def start(self):
if self.has_status_led:
async_call(self.stepper.is_status_led_enabled, None, self.status_led_action.setChecked, self.increase_error_count)
self.update_timer.start(100)
self.update_start()
def stop(self):
self.update_timer.stop()
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickStepper.DEVICE_IDENTIFIER
def cb_position_reached(self, position):
self.position_update(position)
self.endis_all(True)
def disable_list(self, button_list):
for button in button_list:
button.setEnabled(False)
def endis_all(self, value):
self.forward_button.setEnabled(value)
self.stop_button.setEnabled(value)
self.backward_button.setEnabled(value)
self.to_button.setEnabled(value)
self.steps_button.setEnabled(value)
self.full_brake_button.setEnabled(value)
def mode_changed(self, index):
try:
self.stepper.set_step_mode(1 << index)
self.mod = 1 << index
except ip_connection.Error:
return
def forward_clicked(self):
try:
self.stepper.drive_forward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def backward_clicked(self):
try:
self.stepper.drive_backward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def stop_clicked(self):
try:
self.stepper.stop()
except ip_connection.Error:
return
self.endis_all(True)
def full_brake_clicked(self):
try:
self.stepper.full_brake()
except ip_connection.Error:
return
self.endis_all(True)
def to_button_clicked(self):
drive_to = self.to_spin.value()
try:
self.stepper.set_target_position(drive_to)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def steps_button_clicked(self):
drive_steps = self.steps_spin.value()
try:
self.stepper.set_steps(drive_steps)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def motor_current_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(2500)
qid.setIntStep(100)
async_call(self.stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.motor_current_selected)
qid.setLabelText("Choose motor current in mA.")
qid.open()
def minimum_motor_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(40000)
qid.setIntStep(100)
async_call(self.stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.minimum_motor_voltage_selected)
qid.setLabelText("Choose minimum motor voltage in mV.")
qid.open()
def motor_current_selected(self, value):
try:
self.stepper.set_motor_current(value)
except ip_connection.Error:
return
def minimum_motor_voltage_selected(self, value):
try:
self.stepper.set_minimum_voltage(value)
except ip_connection.Error:
return
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov/1000.0, 1)
if not self.qem.isVisible():
self.qem.showMessage("Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str,
"Stepper_UnderVoltage")
def enable_toggled(self, checked):
try:
if checked:
if not self.stepper.is_enabled():
self.endis_all(True)
self.stepper.enable()
else:
if self.stepper.is_enabled():
self.endis_all(False)
self.stepper.disable()
except ip_connection.Error:
return
def sync_rect_toggled(self, checked):
if not self.setting_sync_rect_checkbox and checked:
rc = QMessageBox.warning(get_main_window(), 'Synchronous Rectification',
'If you want to use high speeds (> 10000 steps/s) for a large stepper motor with a ' +
'large inductivity we strongly suggest that you do not enable synchronous rectification. ' +
'Otherwise the Brick may not be able to cope with the load and overheat.',
QMessageBox.Ok | QMessageBox.Cancel)
if rc != QMessageBox.Ok:
self.sync_rect_checkbox.setChecked(False)
return
try:
self.stepper.set_sync_rect(checked)
except ip_connection.Error:
return
self.decay_widget.setVisible(checked)
def stack_input_voltage_update(self, sv):
sv_str = "%gV" % round(sv/1000.0, 1)
self.stack_voltage_label.setText(sv_str)
def external_input_voltage_update(self, ev):
ev_str = "%gV" % round(ev/1000.0, 1)
self.external_voltage_label.setText(ev_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv/1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def maximum_current_update(self, cur):
cur_str = "%gA" % round(cur/1000.0, 1)
self.maximum_current_label.setText(cur_str)
def position_update(self, pos):
pos_str = "%d" % pos
self.position_label.setText(pos_str)
def remaining_steps_update(self, ste):
ste_str = "%d" % ste
self.remaining_steps_label.setText(ste_str)
def current_velocity_update(self, velocity):
velocity_str = "%d" % velocity
self.current_velocity_label.setText(velocity_str)
self.speedometer.set_velocity(velocity)
def mode_update(self, mod):
if mod == 8:
index = 3
elif mod == 4:
index = 2
elif mod == 2:
index = 1
else:
index = 0
self.mode_dropbox.setCurrentIndex(index)
def get_max_velocity_async(self, velocity):
if not self.velocity_slider.isSliderDown():
if velocity != self.velocity_slider.sliderPosition():
self.velocity_slider.setSliderPosition(velocity)
self.velocity_spin.setValue(velocity)
def get_speed_ramping_async(self, ramp):
acc, dec = ramp
if not self.acceleration_slider.isSliderDown() and \
not self.deceleration_slider.isSliderDown():
if acc != self.acceleration_slider.sliderPosition():
self.acceleration_slider.setSliderPosition(acc)
self.acceleration_spin.setValue(acc)
if dec != self.deceleration_slider.sliderPosition():
self.deceleration_slider.setSliderPosition(dec)
self.deceleration_spin.setValue(dec)
def get_decay_async(self, decay):
if not self.decay_slider.isSliderDown():
if decay != self.decay_slider.sliderPosition():
self.decay_slider.setSliderPosition(decay)
self.decay_spin.setValue(decay)
def is_enabled_async(self, enabled):
if enabled:
if not self.enable_checkbox.isChecked():
self.endis_all(True)
self.enable_checkbox.setChecked(True)
else:
if self.enable_checkbox.isChecked():
self.endis_all(False)
self.enable_checkbox.setChecked(False)
def is_sync_rect_async(self, sync_rect):
self.setting_sync_rect_checkbox = True
self.sync_rect_checkbox.setChecked(sync_rect)
self.setting_sync_rect_checkbox = False
def update_start(self):
async_call(self.stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count)
async_call(self.stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count)
async_call(self.stepper.get_decay, None, self.get_decay_async, self.increase_error_count)
async_call(self.stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count)
async_call(self.stepper.is_sync_rect, None, self.is_sync_rect_async, self.increase_error_count)
def update_data(self):
async_call(self.stepper.get_remaining_steps, None, self.remaining_steps_update, self.increase_error_count)
async_call(self.stepper.get_current_position, None, self.position_update, self.increase_error_count)
async_call(self.stepper.get_current_velocity, None, self.current_velocity_update, self.increase_error_count)
self.update_counter += 1
if self.update_counter % 10 == 0:
async_call(self.stepper.get_motor_current, None, self.maximum_current_update, self.increase_error_count)
async_call(self.stepper.get_stack_input_voltage, None, self.stack_input_voltage_update, self.increase_error_count)
async_call(self.stepper.get_external_input_voltage, None, self.external_input_voltage_update, self.increase_error_count)
async_call(self.stepper.get_minimum_voltage, None, self.minimum_voltage_update, self.increase_error_count)
async_call(self.stepper.get_step_mode, None, self.mode_update, self.increase_error_count)
def velocity_changed(self, value):
try:
self.stepper.set_max_velocity(value)
except ip_connection.Error:
return
def acceleration_changed(self, value):
dec = self.deceleration_spin.value()
try:
self.stepper.set_speed_ramping(value, dec)
except ip_connection.Error:
return
def deceleration_changed(self, value):
acc = self.acceleration_slider.value()
try:
self.stepper.set_speed_ramping(acc, value)
except ip_connection.Error:
return
def decay_changed(self, value):
try:
self.stepper.set_decay(value)
except ip_connection.Error:
return
class SilentStepper(PluginBase, Ui_SilentStepper):
qtcb_position_reached = pyqtSignal(int)
qtcb_under_voltage = pyqtSignal(int)
def __init__(self, *args):
PluginBase.__init__(self, BrickSilentStepper, *args)
self.setupUi(self)
self.silent_stepper = self.device
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.speedometer = SpeedoMeter()
self.vertical_layout_right.insertWidget(5, self.speedometer)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
# Step Configuration
self.step_resolution_dropbox.currentIndexChanged.connect(self.step_configuration_changed)
self.interpolate_checkbox.stateChanged.connect(self.step_configuration_changed)
# Basic Configuration
self.standstill_current_spin.valueChanged.connect(self.basic_configuration_changed)
self.motor_run_current_spin.valueChanged.connect(self.basic_configuration_changed)
self.standstill_delay_time_spin.valueChanged.connect(self.basic_configuration_changed)
self.power_down_time_spin.valueChanged.connect(self.basic_configuration_changed)
self.stealth_threshold_spin.valueChanged.connect(self.basic_configuration_changed)
self.coolstep_threashold_spin.valueChanged.connect(self.basic_configuration_changed)
self.classic_threshold_spin.valueChanged.connect(self.basic_configuration_changed)
self.high_velocity_chopper_mode_checkbox.stateChanged.connect(self.basic_configuration_changed)
# Spreadcycle Configuration
self.slow_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.enable_random_slow_decay_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed)
self.fast_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.hysteresis_start_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.hysteresis_end_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.sine_wave_offset_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.chopper_mode_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed)
self.comparator_blank_time_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed)
self.fast_decay_without_comparator_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed)
# Stealth Configuration
self.enable_stealth_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.amplitude_spin.valueChanged.connect(self.stealth_configuration_changed)
self.gradient_spin.valueChanged.connect(self.stealth_configuration_changed)
self.enable_autoscale_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.force_symmetric_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.freewheel_mode_combo.currentIndexChanged.connect(self.stealth_configuration_changed)
# Coolstep Configuration
self.minimum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.maximum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.current_up_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.current_down_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.minimum_current_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.stallguard_threshold_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.stallguard_mode_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
# Misc Configuration
self.disable_short_to_ground_protection_checkbox.stateChanged.connect(self.misc_configuration_changed)
self.synchronize_phase_frequency_spin.valueChanged.connect(self.misc_configuration_changed)
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(lambda checked: self.silent_stepper.enable_status_led() if checked else self.silent_stepper.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.silent_stepper.reset())
self.set_actions([(0, None, [reset])])
def start(self):
async_call(self.silent_stepper.is_status_led_enabled, None, self.status_led_action.setChecked, self.increase_error_count)
self.update_timer.start(100)
self.update_start()
def stop(self):
self.update_timer.stop()
def destroy(self):
pass
@staticmethod
def has_device_identifier(device_identifier):
return device_identifier == BrickSilentStepper.DEVICE_IDENTIFIER
def cb_position_reached(self, position):
self.position_update(position)
self.endis_all(True)
def disable_list(self, button_list):
for button in button_list:
button.setEnabled(False)
def endis_all(self, value):
self.forward_button.setEnabled(value)
self.stop_button.setEnabled(value)
self.backward_button.setEnabled(value)
self.to_button.setEnabled(value)
self.steps_button.setEnabled(value)
self.full_brake_button.setEnabled(value)
def step_configuration_changed(self, _):
step_resolution = self.step_resolution_dropbox.currentIndex()
interpolation = self.interpolate_checkbox.isChecked()
try:
self.silent_stepper.set_step_configuration(step_resolution, interpolation)
except ip_connection.Error:
return
def basic_configuration_changed(self, _):
standstill_current = self.standstill_current_spin.value()
motor_run_current = self.motor_run_current_spin.value()
standstill_delay_time = self.standstill_delay_time_spin.value()
power_down_time = self.power_down_time_spin.value()
stealth_threshold = self.stealth_threshold_spin.value()
coolstep_threshold = self.coolstep_threashold_spin.value()
classic_threshold = self.classic_threshold_spin.value()
high_velocity_chopper_mode = self.high_velocity_chopper_mode_checkbox.isChecked()
try:
self.silent_stepper.set_basic_configuration(standstill_current, motor_run_current, standstill_delay_time, power_down_time, stealth_threshold, coolstep_threshold, classic_threshold, high_velocity_chopper_mode)
except ip_connection.Error:
return
def spreadcycle_configuration_changed(self, _):
slow_decay_duration = self.slow_decay_duration_spin.value()
enable_random_slow_decay = self.enable_random_slow_decay_checkbox.isChecked()
fast_decay_duration = self.fast_decay_duration_spin.value()
hysteresis_start_value = self.hysteresis_start_value_spin.value()
hysteresis_end_value = self.hysteresis_end_value_spin.value()
sine_wave_offset = self.sine_wave_offset_spin.value()
chopper_mode = self.chopper_mode_combo.currentIndex()
comparator_blank_time = self.comparator_blank_time_combo.currentIndex()
fast_decay_without_comparator = self.fast_decay_without_comparator_checkbox.isChecked()
try:
self.silent_stepper.set_spreadcycle_configuration(slow_decay_duration, enable_random_slow_decay, fast_decay_duration, hysteresis_start_value, hysteresis_end_value, sine_wave_offset, chopper_mode, comparator_blank_time, fast_decay_without_comparator)
except ip_connection.Error:
return
def stealth_configuration_changed(self, _):
enable_stealth = self.enable_stealth_checkbox.isChecked()
amplitude = self.amplitude_spin.value()
gradient = self.gradient_spin.value()
enable_autoscale = self.enable_autoscale_checkbox.isChecked()
force_symmetric = self.force_symmetric_checkbox.isChecked()
freewheel_mode = self.freewheel_mode_combo.currentIndex()
try:
self.silent_stepper.set_stealth_configuration(enable_stealth, amplitude, gradient, enable_autoscale, force_symmetric, freewheel_mode)
except ip_connection.Error:
return
def coolstep_configuration_changed(self, _):
minimum_stallguard_value = self.minimum_stallguard_value_spin.value()
maximum_stallguard_value = self.maximum_stallguard_value_spin.value()
current_up_step_width = self.current_up_step_width_combo.currentIndex()
current_down_step_width = self.current_down_step_width_combo.currentIndex()
minimum_current = self.minimum_current_combo.currentIndex()
stallguard_threshold_value = self.stallguard_threshold_value_spin.value()
stallguard_mode = self.stallguard_mode_combo.currentIndex()
try:
self.silent_stepper.set_coolstep_configuration(minimum_stallguard_value, maximum_stallguard_value, current_up_step_width, current_down_step_width, minimum_current, stallguard_threshold_value, stallguard_mode)
except ip_connection.Error:
return
def misc_configuration_changed(self, _):
disable_short_to_ground_protection = self.disable_short_to_ground_protection_checkbox.isChecked()
synchronize_phase_frequency = self.synchronize_phase_frequency_spin.value()
try:
self.silent_stepper.set_misc_configuration(disable_short_to_ground_protection, synchronize_phase_frequency)
except ip_connection.Error:
return
def forward_clicked(self):
try:
self.silent_stepper.drive_forward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def backward_clicked(self):
try:
self.silent_stepper.drive_backward()
except ip_connection.Error:
return
self.disable_list([self.to_button, self.steps_button])
def stop_clicked(self):
try:
self.silent_stepper.stop()
except ip_connection.Error:
return
self.endis_all(True)
def full_brake_clicked(self):
try:
self.silent_stepper.full_brake()
except ip_connection.Error:
return
self.endis_all(True)
def to_button_clicked(self):
drive_to = self.to_spin.value()
try:
self.silent_stepper.set_target_position(drive_to)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def steps_button_clicked(self):
drive_steps = self.steps_spin.value()
try:
self.silent_stepper.set_steps(drive_steps)
except ip_connection.Error:
return
self.disable_list([self.to_button,
self.steps_button,
self.forward_button,
self.backward_button])
def motor_current_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(360)
qid.setIntMaximum(1640)
qid.setIntStep(100)
async_call(self.silent_stepper.get_motor_current, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.motor_current_selected)
qid.setLabelText("Choose motor current in mA.")
qid.open()
def minimum_motor_voltage_button_clicked(self):
qid = QInputDialog(self)
qid.setInputMode(QInputDialog.IntInput)
qid.setIntMinimum(0)
qid.setIntMaximum(40000)
qid.setIntStep(100)
async_call(self.silent_stepper.get_minimum_voltage, None, qid.setIntValue, self.increase_error_count)
qid.intValueSelected.connect(self.minimum_motor_voltage_selected)
qid.setLabelText("Choose minimum motor voltage in mV.")
qid.open()
def motor_current_selected(self, value):
try:
self.silent_stepper.set_motor_current(value)
except ip_connection.Error:
return
def minimum_motor_voltage_selected(self, value):
try:
self.silent_stepper.set_minimum_voltage(value)
except ip_connection.Error:
return
def cb_under_voltage(self, ov):
mv_str = self.minimum_voltage_label.text()
ov_str = "%gV" % round(ov/1000.0, 1)
if not self.qem.isVisible():
self.qem.showMessage("Under Voltage: Output Voltage of " + ov_str +
" is below minimum voltage of " + mv_str,
"SilentStepper_UnderVoltage")
def enable_state_changed(self, state):
try:
if state == Qt.Checked:
self.endis_all(True)
self.silent_stepper.enable()
elif state == Qt.Unchecked:
self.endis_all(False)
self.silent_stepper.disable()
except ip_connection.Error:
return
def stack_input_voltage_update(self, sv):
sv_str = "%gV" % round(sv/1000.0, 1)
self.stack_voltage_label.setText(sv_str)
def external_input_voltage_update(self, ev):
ev_str = "%gV" % round(ev/1000.0, 1)
self.external_voltage_label.setText(ev_str)
def minimum_voltage_update(self, mv):
mv_str = "%gV" % round(mv/1000.0, 1)
self.minimum_voltage_label.setText(mv_str)
def maximum_current_update(self, cur):
cur_str = "%gA" % round(cur/1000.0, 1)
self.maximum_current_label.setText(cur_str)
def position_update(self, pos):
pos_str = "%d" % pos
self.position_label.setText(pos_str)
def remaining_steps_update(self, ste):
ste_str = "%d" % ste
self.remaining_steps_label.setText(ste_str)
def driver_status_update(self, update):
if update.open_load == 0:
self.status_open_load.setText('No')
elif update.open_load == 1:
self.status_open_load.setText('Phase A')
elif update.open_load == 2:
self.status_open_load.setText('Phase B')
elif update.open_load == 3:
self.status_open_load.setText('Phase A and B')
else:
self.status_open_load.setText('Unknown')
if update.short_to_ground == 0:
self.status_short_to_ground.setText('No')
elif update.short_to_ground == 1:
self.status_short_to_ground.setText('Phase A')
elif update.short_to_ground == 2:
self.status_short_to_ground.setText('Phase B')
elif update.short_to_ground == 3:
self.status_short_to_ground.setText('Phase A and B')
else:
self.status_short_to_ground.setText('Unknown')
if update.over_temperature == 0:
self.status_over_temperature.setText('No')
elif update.over_temperature == 1:
self.status_over_temperature.setText('<font color=yellow>Warning</font>')
elif update.over_temperature == 2:
self.status_over_temperature.setText('<font color=red>Limit</font>')
if update.motor_stalled:
self.status_motor_stalled.setText('Yes')
else:
self.status_motor_stalled.setText('No')
self.status_actual_motor_current.setText(str(update.actual_motor_current))
if update.full_step_active:
self.status_full_step_active.setText('Yes')
else:
self.status_full_step_active.setText('No')
self.status_stallguard_result.setText(str(update.stallguard_result))
self.status_stealth_voltage_amplitude.setText(str(update.stealth_voltage_amplitude))
def get_max_velocity_async(self, velocity):
if not self.velocity_slider.isSliderDown():
if velocity != self.velocity_slider.sliderPosition():
self.velocity_slider.setSliderPosition(velocity)
self.velocity_spin.setValue(velocity)
def get_speed_ramping_async(self, ramp):
acc, dec = ramp
if not self.acceleration_slider.isSliderDown() and \
not self.deceleration_slider.isSliderDown():
if acc != self.acceleration_slider.sliderPosition():
self.acceleration_slider.setSliderPosition(acc)
self.acceleration_spin.setValue(acc)
if dec != self.deceleration_slider.sliderPosition():
self.deceleration_slider.setSliderPosition(dec)
self.deceleration_spin.setValue(dec)
def is_enabled_async(self, enabled):
if enabled:
if not self.enable_checkbox.isChecked():
self.endis_all(True)
self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(True)
self.enable_checkbox.blockSignals(False)
else:
if self.enable_checkbox.isChecked():
self.endis_all(False)
self.enable_checkbox.blockSignals(True)
self.enable_checkbox.setChecked(False)
self.enable_checkbox.blockSignals(False)
def get_step_configuration_async(self, conf):
self.step_resolution_dropbox.blockSignals(True)
self.step_resolution_dropbox.setCurrentIndex(conf.step_resolution)
self.step_resolution_dropbox.blockSignals(False)
self.interpolate_checkbox.blockSignals(True)
self.interpolate_checkbox.setChecked(conf.interpolation)
self.interpolate_checkbox.blockSignals(False)
def get_basic_configuration_async(self, conf):
self.standstill_current_spin.blockSignals(True)
self.standstill_current_spin.setValue(conf.standstill_current)
self.standstill_current_spin.blockSignals(False)
self.motor_run_current_spin.blockSignals(True)
self.motor_run_current_spin.setValue(conf.motor_run_current)
self.motor_run_current_spin.blockSignals(False)
self.standstill_delay_time_spin.blockSignals(True)
self.standstill_delay_time_spin.setValue(conf.standstill_delay_time)
self.standstill_delay_time_spin.blockSignals(False)
self.power_down_time_spin.blockSignals(True)
self.power_down_time_spin.setValue(conf.power_down_time)
self.power_down_time_spin.blockSignals(False)
self.stealth_threshold_spin.blockSignals(True)
self.stealth_threshold_spin.setValue(conf.stealth_threshold)
self.stealth_threshold_spin.blockSignals(False)
self.coolstep_threashold_spin.blockSignals(True)
self.coolstep_threashold_spin.setValue(conf.coolstep_threshold)
self.coolstep_threashold_spin.blockSignals(False)
self.classic_threshold_spin.blockSignals(True)
self.classic_threshold_spin.setValue(conf.classic_threshold)
self.classic_threshold_spin.blockSignals(False)
self.high_velocity_chopper_mode_checkbox.blockSignals(True)
self.high_velocity_chopper_mode_checkbox.setChecked(conf.high_velocity_chopper_mode)
self.high_velocity_chopper_mode_checkbox.blockSignals(False)
def get_spreadcycle_configuration_async(self, conf):
self.slow_decay_duration_spin.blockSignals(True)
self.slow_decay_duration_spin.setValue(conf.slow_decay_duration)
self.slow_decay_duration_spin.blockSignals(False)
self.enable_random_slow_decay_checkbox.blockSignals(True)
self.enable_random_slow_decay_checkbox.setChecked(conf.enable_random_slow_decay)
self.enable_random_slow_decay_checkbox.blockSignals(False)
self.fast_decay_duration_spin.blockSignals(True)
self.fast_decay_duration_spin.setValue(conf.fast_decay_duration)
self.fast_decay_duration_spin.blockSignals(False)
self.hysteresis_start_value_spin.blockSignals(True)
self.hysteresis_start_value_spin.setValue(conf.hysteresis_start_value)
self.hysteresis_start_value_spin.blockSignals(False)
self.hysteresis_end_value_spin.blockSignals(True)
self.hysteresis_end_value_spin.setValue(conf.hysteresis_end_value)
self.hysteresis_end_value_spin.blockSignals(False)
self.sine_wave_offset_spin.blockSignals(True)
self.sine_wave_offset_spin.setValue(conf.sine_wave_offset)
self.sine_wave_offset_spin.blockSignals(False)
self.chopper_mode_combo.blockSignals(True)
self.chopper_mode_combo.setCurrentIndex(conf.chopper_mode)
self.chopper_mode_combo.blockSignals(False)
self.standstill_current_spin.blockSignals(True)
self.comparator_blank_time_combo.setCurrentIndex(conf.comparator_blank_time)
self.standstill_current_spin.blockSignals(False)
self.fast_decay_without_comparator_checkbox.blockSignals(True)
self.fast_decay_without_comparator_checkbox.setChecked(conf.fast_decay_without_comparator)
self.fast_decay_without_comparator_checkbox.blockSignals(False)
def get_stealth_configuration_async(self, conf):
self.enable_stealth_checkbox.blockSignals(True)
self.enable_stealth_checkbox.setChecked(conf.enable_stealth)
self.enable_stealth_checkbox.blockSignals(False)
self.amplitude_spin.blockSignals(True)
self.amplitude_spin.setValue(conf.amplitude)
self.amplitude_spin.blockSignals(False)
self.gradient_spin.blockSignals(True)
self.gradient_spin.setValue(conf.gradient)
self.gradient_spin.blockSignals(False)
self.enable_autoscale_checkbox.blockSignals(True)
self.enable_autoscale_checkbox.setChecked(conf.enable_autoscale)
self.enable_autoscale_checkbox.blockSignals(False)
self.force_symmetric_checkbox.blockSignals(True)
self.force_symmetric_checkbox.setChecked(conf.force_symmetric)
self.force_symmetric_checkbox.blockSignals(False)
self.freewheel_mode_combo.blockSignals(True)
self.freewheel_mode_combo.setCurrentIndex(conf.freewheel_mode)
self.freewheel_mode_combo.blockSignals(False)
def get_coolstep_configuration_async(self, conf):
self.minimum_stallguard_value_spin.blockSignals(True)
self.minimum_stallguard_value_spin.setValue(conf.minimum_stallguard_value)
self.minimum_stallguard_value_spin.blockSignals(False)
self.maximum_stallguard_value_spin.blockSignals(True)
self.maximum_stallguard_value_spin.setValue(conf.maximum_stallguard_value)
self.maximum_stallguard_value_spin.blockSignals(False)
self.current_up_step_width_combo.blockSignals(True)
self.current_up_step_width_combo.setCurrentIndex(conf.current_up_step_width)
self.current_up_step_width_combo.blockSignals(False)
self.current_down_step_width_combo.blockSignals(True)
self.current_down_step_width_combo.setCurrentIndex(conf.current_down_step_width)
self.current_down_step_width_combo.blockSignals(False)
self.minimum_current_combo.blockSignals(True)
self.minimum_current_combo.setCurrentIndex(conf.minimum_current)
self.minimum_current_combo.blockSignals(False)
self.stallguard_threshold_value_spin.blockSignals(True)
self.stallguard_threshold_value_spin.setValue(conf.stallguard_threshold_value)
self.stallguard_threshold_value_spin.blockSignals(False)
self.stallguard_mode_combo.blockSignals(True)
self.stallguard_mode_combo.setCurrentIndex(conf.stallguard_mode)
self.stallguard_mode_combo.blockSignals(False)
def get_misc_configuration_async(self, conf):
self.disable_short_to_ground_protection_checkbox.blockSignals(True)
self.disable_short_to_ground_protection_checkbox.setChecked(conf.disable_short_to_ground_protection)
self.disable_short_to_ground_protection_checkbox.blockSignals(False)
self.synchronize_phase_frequency_spin.blockSignals(True)
self.synchronize_phase_frequency_spin.setValue(conf.synchronize_phase_frequency)
self.synchronize_phase_frequency_spin.blockSignals(False)
def update_start(self):
async_call(self.silent_stepper.get_max_velocity, None, self.get_max_velocity_async, self.increase_error_count)
async_call(self.silent_stepper.get_speed_ramping, None, self.get_speed_ramping_async, self.increase_error_count)
async_call(self.silent_stepper.is_enabled, None, self.is_enabled_async, self.increase_error_count)
async_call(self.silent_stepper.get_step_configuration, None, self.get_step_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_basic_configuration, None, self.get_basic_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_spreadcycle_configuration, None, self.get_spreadcycle_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_stealth_configuration, None, self.get_stealth_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_coolstep_configuration, None, self.get_coolstep_configuration_async, self.increase_error_count)
async_call(self.silent_stepper.get_misc_configuration, None, self.get_misc_configuration_async, self.increase_error_count)
def update_data(self):
async_call(self.silent_stepper.get_remaining_steps, None, self.remaining_steps_update, self.increase_error_count)
async_call(self.silent_stepper.get_current_position, None, self.position_update, self.increase_error_count)
async_call(self.silent_stepper.get_current_velocity, None, self.speedometer.set_velocity, self.increase_error_count)
self.update_counter += 1
if self.update_counter % 10 == 0:
async_call(self.silent_stepper.get_motor_current, None, self.maximum_current_update, self.increase_error_count)
async_call(self.silent_stepper.get_stack_input_voltage, None, self.stack_input_voltage_update, self.increase_error_count)
async_call(self.silent_stepper.get_external_input_voltage, None, self.external_input_voltage_update, self.increase_error_count)
async_call(self.silent_stepper.get_minimum_voltage, None, self.minimum_voltage_update, self.increase_error_count)
async_call(self.silent_stepper.get_driver_status, None, self.driver_status_update, self.increase_error_count)
def velocity_changed(self, value):
try:
self.silent_stepper.set_max_velocity(value)
except ip_connection.Error:
return
def acceleration_changed(self, value):
dec = self.deceleration_spin.value()
try:
self.silent_stepper.set_speed_ramping(value, dec)
except ip_connection.Error:
return
def deceleration_changed(self, value):
acc = self.acceleration_slider.value()
try:
self.silent_stepper.set_speed_ramping(acc, value)
except ip_connection.Error:
return
def __init__(self, *args):
PluginBase.__init__(self, BrickStepper, *args)
self.setupUi(self)
self.stepper = self.device
# the firmware version of a Brick can (under common circumstances) not
# change during the lifetime of a Brick plugin. therefore, it's okay to
# make final decisions based on it here
self.has_status_led = self.firmware_version >= (2, 3, 1)
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.decay_widget.hide()
self.setting_sync_rect_checkbox = False
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.decay_syncer = SliderSpinSyncer(self.decay_slider,
self.decay_spin,
self.decay_changed)
self.enable_checkbox.toggled.connect(self.enable_toggled)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked)
self.sync_rect_checkbox.toggled.connect(self.sync_rect_toggled)
self.mode_dropbox.currentIndexChanged.connect(self.mode_changed)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.stepper.register_callback(self.stepper.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.stepper.register_callback(self.stepper.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
if self.has_status_led:
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(lambda checked: self.stepper.enable_status_led() if checked else self.stepper.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
else:
self.status_led_action = None
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.stepper.reset())
self.set_actions([(0, None, [reset])])
def connectLocalCamera(self) :
self.close()
qem = QErrorMessage()
qem.showMessage('Не удаётся подключиться к Raspberry Pi: Будет подключена локальная камера')
qem.exec()
self._capturedDevice = cv2.VideoCapture(0)
def __init__(self, navdb):
super(Gui, self).__init__([])
self.acdata = ACDataEvent()
self.navdb = navdb
self.radarwidget = []
self.command_history = []
self.cmdargs = []
self.history_pos = 0
self.command_mem = ''
self.command_line = ''
self.prev_cmdline = ''
self.simevent_target = 0
self.mousedragged = False
self.mousepos = (0, 0)
self.prevmousepos = (0, 0)
self.panzoomchanged = False
self.simt = 0.0
# Register our custom pan/zoom event
for etype in [PanZoomEventType, ACDataEventType, SimInfoEventType,
StackTextEventType, ShowDialogEventType,
DisplayFlagEventType, RouteDataEventType,
DisplayShapeEventType, SimQuitEventType,
AMANEventType]:
reg_etype = QEvent.registerEventType(etype)
if reg_etype != etype:
print('Warning: Registered event type differs from requested type id (%d != %d)' % (reg_etype, etype))
self.splash = Splash()
self.splash.show()
self.splash.showMessage('Constructing main window')
self.processEvents()
# Install error message handler
handler = QErrorMessage.qtHandler()
handler.setWindowFlags(Qt.WindowStaysOnTopHint)
# Check and set OpenGL capabilities
if not QGLFormat.hasOpenGL():
raise RuntimeError('No OpenGL support detected for this system!')
else:
f = QGLFormat()
f.setVersion(3, 3)
f.setProfile(QGLFormat.CoreProfile)
f.setDoubleBuffer(True)
QGLFormat.setDefaultFormat(f)
print('QGLWidget initialized for OpenGL version %d.%d' % (f.majorVersion(), f.minorVersion()))
# Create the main window and related widgets
self.radarwidget = RadarWidget(navdb)
self.win = MainWindow(self, self.radarwidget)
self.nd = ND(shareWidget=self.radarwidget)
#self.aman = AMANDisplay(shareWidget=self.radarwidget)
# Enable HiDPI support (Qt5 only)
if QT_VERSION == 5:
self.setAttribute(Qt.AA_UseHighDpiPixmaps)
timer = QTimer(self)
timer.timeout.connect(self.radarwidget.updateGL)
timer.timeout.connect(self.nd.updateGL)
#timer.timeout.connect(self.aman.updateGL)
timer.start(50)
class Synchronizer(Tool):
def __init__(self, videoWidget, subtitleData, parent=None):
super().__init__(parent)
self._models = defaultdict(self._modelFactory) # path : QStandardItemModel
self._current = None
self._videoWidget = videoWidget
self._subtitleData = subtitleData
# avoid unnecessary copies in each addPoint() call
self._err = QErrorMessage()
self._table = None
self._subtitleData.fileChanged.connect(self._fileChanged)
self._subtitleData.subtitlesChanged.connect(self._subtitlesChanged)
self._subtitleData.subtitlesAdded.connect(self._subtitlesAdded)
self._subtitleData.subtitlesRemoved.connect(self._subtitlesRemoved)
@property
def name(self):
return _("Synchronize")
def setContent(self, widget):
path = widget.filePath
model = self._models[path]
data = self._subtitleData.data(widget.filePath)
self._current = _CurrentData(data, model, widget)
if self._table is None: # e.g. when switched from file list
self.clear()
self._table = self._makeTable(model)
self.layout().addWidget(self._table, stretch=1)
self.layout().addWidget(_Controls(self), stretch=0)
else:
self._table.setModel(model)
self._updateRmButtons()
def clear(self):
super().clear()
self._table = None
def remove(self, path):
if path in self._models:
del self._models[path]
def setTopLevelWindow(self):
self.raise_()
self.activateWindow()
def apply(self):
syncpoints = _syncPoints(self._current.model)
if len(syncpoints) == 0:
return
ts = TimeSync(self._current.data.subtitles) # in-place sync
ts.sync(syncpoints)
command = ChangeData(self._current.editor.filePath, self._current.data,
_("Subtitles synchronization"))
self._subtitleData.execute(command)
@pyqtSlot()
def addPoint(self):
rows = self._current.editor.selectedRows()
newStart = self._videoWidget.position
if len(rows) == 0 or newStart is None:
self._err.showMessage(_("Select a subtitle and position in current video first."))
return
# row and sub reflect the same subtitle, but we need both for different things
row = rows[0]
sub = self._current.data.subtitles[row]
# Don't add the same subtitle or the same sync time twice
if any(row == point.subNo or newStart == point.start
for point in _syncPoints(self._current.model)):
self._err.showMessage(_("Can't repeat synchronization points"))
return
if sub.fps != newStart.fps:
self._err.showMessage(_("Subtitle and video have different framerates (%(sub)s vs"
"%(vid)s") % dict(sub=sub.fps, vid=newStart.fps))
return
delta = sub.end - sub.start
newEnd = newStart + delta
startItem, endItem, textItem = createRow(sub, newStart, newEnd)
subNoItem = QStandardItem(str(row))
subNoItem.setEditable(False)
textItem.setEditable(False)
rmItem = QStandardItem("")
self._current.model.appendRow([subNoItem, startItem, endItem, textItem, rmItem])
self._rmButton(self._table, rmItem)
def removeSelected(self):
indices = self._table.selectedIndexes()
if len(indices) > 0:
rows = list(set([index.row() for index in indices]))
rows.sort(reverse=True)
for row in rows:
self.removeRow(row)
if self._current.model.rowCount() > rows[-1]:
self._table.selectRow(rows[-1])
else:
self._table.selectRow(self._current.model.rowCount() - 1)
@pyqtSlot(int)
def removeRow(self, no):
self._current.model.removeRow(no)
def keyPressEvent(self, keyEvent):
if keyEvent.key() == Qt.Key_Delete:
self.removeSelected()
else:
super().keyPressEvent(keyEvent)
def _makeTable(self, model):
table = QTableView(self)
table.setModel(model)
table.hideColumn(0)
table.setShowGrid(False)
subListDelegate = SubListItemDelegate()
table.setItemDelegateForColumn(1, subListDelegate)
table.setItemDelegateForColumn(2, subListDelegate)
table.horizontalHeader().setSectionResizeMode(3, QHeaderView.Stretch)
table.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeToContents)
return table
def _modelFactory(self):
model = QStandardItemModel(0, 5, self)
model.setHorizontalHeaderLabels([_("No."), _("New begin"), _("New end"),
_("Subtitle"), ""])
return model
def _rmButton(self, table, item):
rmButton = QPushButton(QIcon.fromTheme("list-remove"), "")
rmButton.setFlat(True)
table.setIndexWidget(item.index(), rmButton)
rmButton.clicked.connect(lambda _, i=item: self.removeRow(i.row()))
def _updateRmButtons(self):
if self._table is None: # safety check
return
for row in range(self._current.model.rowCount()):
item = self._current.model.item(row, 4)
self._rmButton(self._table, item)
def _fileChanged(self, path):
model = self._models.get(path)
if model is None:
return
subtitles = self._subtitleData.subtitles(path)
for row in range(model.rowCount()):
subNo = _subNo(model, row)
sub = subtitles[subNo]
# clear model when things don't match pretty badly
if subNo >= len(subtitles):
model.removeRows(0, model.rowCount())
return
_setText(sub.text, model, row)
def _subtitlesChanged(self, path, subNos):
model = self._models.get(path)
if model is None:
return
subtitles = self._subtitleData.subtitles(path)
for no in subNos:
sub = subtitles[no]
row = _findRow(no, model)
if row is not None:
_setText(sub.text, model, row)
def _subtitlesAdded(self, path, subNos):
"""When subtitle is added, all syncPoints greater or equal than a new
subtitle are incremented."""
def action(current, count, model, row):
_setSubNo(current + count, model, row)
def count(current, nos):
ret = 0
for no in nos:
if current >= no:
ret += 1
# consider: current = 0, nos = [0, 1, 2, 3]
# in that case, current should be prepended by all nos
current += 1
return ret
self._changeSubNos(path, subNos, count, action)
def _subtitlesRemoved(self, path, subNos):
"""When subtitle is removed, all syncPoints greater than removed
subtitle are decremented. SyncPoint equal to removed subtitle is also
removed."""
def action(current, count, model, row):
if count.equal > 0:
model.removeRow(row)
else:
_setSubNo(current - count.greater_equal, model, row)
def count(current, nos):
return _GtEqCount(current, nos)
self._changeSubNos(path, subNos, count, action)
def _changeSubNos(self, path, subNos, count, action, reverse=False):
"""Implementation of subs add/removal handling.
Args:
path: file path associated with model on which work is done
subNos: list of added/removed subtitle numbers
count: function which accepts current sync point's subtitle number
and subNos and returns anything based on these values
action: action performed for each of sync point's subtitle number.
Accepts current SyncPoint.subNo, count result, model and
row:
def action(current, count, model, row)
"""
model = self._models.get(path)
if model is None:
return
syncPoints = _syncPoints(model)
syncSubNos = [p.subNo for p in syncPoints]
syncSubNos.sort()
if len(syncSubNos) == 0:
return
for current in syncSubNos:
row = _findRow(current, model)
action(current, count(current, subNos), model, row)
def __init__(self, *args):
PluginBase.__init__(self, BrickSilentStepper, *args)
self.setupUi(self)
self.silent_stepper = self.device
self.endis_all(False)
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self.update_data)
self.speedometer = SpeedoMeter()
self.vertical_layout_right.insertWidget(5, self.speedometer)
self.new_value = 0
self.update_counter = 0
self.full_brake_time = 0
self.qem = QErrorMessage(self)
self.qem.setWindowTitle("Under Voltage")
self.velocity_syncer = SliderSpinSyncer(self.velocity_slider,
self.velocity_spin,
self.velocity_changed)
self.acceleration_syncer = SliderSpinSyncer(self.acceleration_slider,
self.acceleration_spin,
self.acceleration_changed)
self.deceleration_syncer = SliderSpinSyncer(self.deceleration_slider,
self.deceleration_spin,
self.deceleration_changed)
self.enable_checkbox.stateChanged.connect(self.enable_state_changed)
self.forward_button.clicked.connect(self.forward_clicked)
self.stop_button.clicked.connect(self.stop_clicked)
self.full_brake_button.clicked.connect(self.full_brake_clicked)
self.backward_button.clicked.connect(self.backward_clicked)
self.to_button.clicked.connect(self.to_button_clicked)
self.steps_button.clicked.connect(self.steps_button_clicked)
self.motor_current_button.clicked.connect(self.motor_current_button_clicked)
self.minimum_motor_voltage_button.clicked.connect(self.minimum_motor_voltage_button_clicked)
self.qtcb_position_reached.connect(self.cb_position_reached)
self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_POSITION_REACHED,
self.qtcb_position_reached.emit)
self.qtcb_under_voltage.connect(self.cb_under_voltage)
self.silent_stepper.register_callback(self.silent_stepper.CALLBACK_UNDER_VOLTAGE,
self.qtcb_under_voltage.emit)
# Step Configuration
self.step_resolution_dropbox.currentIndexChanged.connect(self.step_configuration_changed)
self.interpolate_checkbox.stateChanged.connect(self.step_configuration_changed)
# Basic Configuration
self.standstill_current_spin.valueChanged.connect(self.basic_configuration_changed)
self.motor_run_current_spin.valueChanged.connect(self.basic_configuration_changed)
self.standstill_delay_time_spin.valueChanged.connect(self.basic_configuration_changed)
self.power_down_time_spin.valueChanged.connect(self.basic_configuration_changed)
self.stealth_threshold_spin.valueChanged.connect(self.basic_configuration_changed)
self.coolstep_threashold_spin.valueChanged.connect(self.basic_configuration_changed)
self.classic_threshold_spin.valueChanged.connect(self.basic_configuration_changed)
self.high_velocity_chopper_mode_checkbox.stateChanged.connect(self.basic_configuration_changed)
# Spreadcycle Configuration
self.slow_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.enable_random_slow_decay_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed)
self.fast_decay_duration_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.hysteresis_start_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.hysteresis_end_value_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.sine_wave_offset_spin.valueChanged.connect(self.spreadcycle_configuration_changed)
self.chopper_mode_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed)
self.comparator_blank_time_combo.currentIndexChanged.connect(self.spreadcycle_configuration_changed)
self.fast_decay_without_comparator_checkbox.stateChanged.connect(self.spreadcycle_configuration_changed)
# Stealth Configuration
self.enable_stealth_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.amplitude_spin.valueChanged.connect(self.stealth_configuration_changed)
self.gradient_spin.valueChanged.connect(self.stealth_configuration_changed)
self.enable_autoscale_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.force_symmetric_checkbox.stateChanged.connect(self.stealth_configuration_changed)
self.freewheel_mode_combo.currentIndexChanged.connect(self.stealth_configuration_changed)
# Coolstep Configuration
self.minimum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.maximum_stallguard_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.current_up_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.current_down_step_width_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.minimum_current_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
self.stallguard_threshold_value_spin.valueChanged.connect(self.coolstep_configuration_changed)
self.stallguard_mode_combo.currentIndexChanged.connect(self.coolstep_configuration_changed)
# Misc Configuration
self.disable_short_to_ground_protection_checkbox.stateChanged.connect(self.misc_configuration_changed)
self.synchronize_phase_frequency_spin.valueChanged.connect(self.misc_configuration_changed)
self.ste = 0
self.pos = 0
self.current_velocity = 0
self.cur = 0
self.sv = 0
self.ev = 0
self.mv = 0
self.mod = 0
self.status_led_action = QAction('Status LED', self)
self.status_led_action.setCheckable(True)
self.status_led_action.toggled.connect(lambda checked: self.silent_stepper.enable_status_led() if checked else self.silent_stepper.disable_status_led())
self.set_configs([(0, None, [self.status_led_action])])
reset = QAction('Reset', self)
reset.triggered.connect(lambda: self.silent_stepper.reset())
self.set_actions([(0, None, [reset])])
def view3d(self):
viewer = "osgviewer"
# look for viewer in the standard path
result = distutils.spawn.find_executable(viewer)
if result == None:
app_path = os.path.split(os.path.abspath(sys.argv[0]))[0]
viewer = os.path.abspath(app_path + "/OpenSceneGraph/bin/osgviewer")
viewerexe = os.path.abspath(app_path + "/OpenSceneGraph/bin/osgviewer.exe")
print "testing for " + viewer + " or " + viewerexe
result = os.path.isfile(viewer) or os.path.isfile(viewerexe)
if not result:
error = QErrorMessage(self)
error.showMessage( "Cannot find " + viewer + " in path. Perhaps it needs to be installed?" )
return
madfile = self.fileroot + ".mad"
if not os.path.exists(madfile):
error = QErrorMessage(self)
error.showMessage( "No '.mad' file ... please save your design with a file name." )
return
if not self.isClean():
error = QErrorMessage(self)
error.showMessage( "The design has been modified. You must <b>Build</b> it before viewing the 3d structure." )
return
acfile = self.fileroot + ".ac"
if not os.path.exists(acfile):
error = QErrorMessage(self)
error.showMessage( "Design needs to be 'built'; click ok to continue." )
#self.build_fast()
return
madtime = os.path.getmtime(madfile)
actime = os.path.getmtime(acfile)
if madtime > actime:
error = QErrorMessage(self)
error.showMessage( "Design needs to be 'built'; click ok to continue." )
#self.build_fast()
return
command = []
command.append(viewer)
command.append("--window")
command.append("50")
command.append("50")
command.append("800")
command.append("600")
command.append(self.fileroot + ".ac")
pid = subprocess.Popen(command).pid
print "spawned osgviewer with pid = " + str(pid)
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.openFilesPath = ''
self.errorMessageDialog = QErrorMessage(self)
frameStyle = QFrame.Sunken | QFrame.Panel
self.integerLabel = QLabel()
self.integerLabel.setFrameStyle(frameStyle)
self.integerButton = QPushButton("QInputDialog.get&Int()")
self.doubleLabel = QLabel()
self.doubleLabel.setFrameStyle(frameStyle)
self.doubleButton = QPushButton("QInputDialog.get&Double()")
self.itemLabel = QLabel()
self.itemLabel.setFrameStyle(frameStyle)
self.itemButton = QPushButton("QInputDialog.getIte&m()")
self.textLabel = QLabel()
self.textLabel.setFrameStyle(frameStyle)
self.textButton = QPushButton("QInputDialog.get&Text()")
self.colorLabel = QLabel()
self.colorLabel.setFrameStyle(frameStyle)
self.colorButton = QPushButton("QColorDialog.get&Color()")
self.fontLabel = QLabel()
self.fontLabel.setFrameStyle(frameStyle)
self.fontButton = QPushButton("QFontDialog.get&Font()")
self.directoryLabel = QLabel()
self.directoryLabel.setFrameStyle(frameStyle)
self.directoryButton = QPushButton("QFileDialog.getE&xistingDirectory()")
self.openFileNameLabel = QLabel()
self.openFileNameLabel.setFrameStyle(frameStyle)
self.openFileNameButton = QPushButton("QFileDialog.get&OpenFileName()")
self.openFileNamesLabel = QLabel()
self.openFileNamesLabel.setFrameStyle(frameStyle)
self.openFileNamesButton = QPushButton("QFileDialog.&getOpenFileNames()")
self.saveFileNameLabel = QLabel()
self.saveFileNameLabel.setFrameStyle(frameStyle)
self.saveFileNameButton = QPushButton("QFileDialog.get&SaveFileName()")
self.criticalLabel = QLabel()
self.criticalLabel.setFrameStyle(frameStyle)
self.criticalButton = QPushButton("QMessageBox.critica&l()")
self.informationLabel = QLabel()
self.informationLabel.setFrameStyle(frameStyle)
self.informationButton = QPushButton("QMessageBox.i&nformation()")
self.questionLabel = QLabel()
self.questionLabel.setFrameStyle(frameStyle)
self.questionButton = QPushButton("QMessageBox.&question()")
self.warningLabel = QLabel()
self.warningLabel.setFrameStyle(frameStyle)
self.warningButton = QPushButton("QMessageBox.&warning()")
self.errorLabel = QLabel()
self.errorLabel.setFrameStyle(frameStyle)
self.errorButton = QPushButton("QErrorMessage.show&M&essage()")
self.integerButton.clicked.connect(self.setInteger)
self.doubleButton.clicked.connect(self.setDouble)
self.itemButton.clicked.connect(self.setItem)
self.textButton.clicked.connect(self.setText)
self.colorButton.clicked.connect(self.setColor)
self.fontButton.clicked.connect(self.setFont)
self.directoryButton.clicked.connect(self.setExistingDirectory)
self.openFileNameButton.clicked.connect(self.setOpenFileName)
self.openFileNamesButton.clicked.connect(self.setOpenFileNames)
self.saveFileNameButton.clicked.connect(self.setSaveFileName)
self.criticalButton.clicked.connect(self.criticalMessage)
self.informationButton.clicked.connect(self.informationMessage)
self.questionButton.clicked.connect(self.questionMessage)
self.warningButton.clicked.connect(self.warningMessage)
self.errorButton.clicked.connect(self.errorMessage)
self.native = QCheckBox()
self.native.setText("Use native file dialog.")
self.native.setChecked(True)
if sys.platform not in ("win32", "darwin"):
self.native.hide()
layout = QGridLayout()
layout.setColumnStretch(1, 1)
layout.setColumnMinimumWidth(1, 250)
layout.addWidget(self.integerButton, 0, 0)
layout.addWidget(self.integerLabel, 0, 1)
layout.addWidget(self.doubleButton, 1, 0)
layout.addWidget(self.doubleLabel, 1, 1)
layout.addWidget(self.itemButton, 2, 0)
layout.addWidget(self.itemLabel, 2, 1)
layout.addWidget(self.textButton, 3, 0)
layout.addWidget(self.textLabel, 3, 1)
layout.addWidget(self.colorButton, 4, 0)
layout.addWidget(self.colorLabel, 4, 1)
layout.addWidget(self.fontButton, 5, 0)
layout.addWidget(self.fontLabel, 5, 1)
layout.addWidget(self.directoryButton, 6, 0)
layout.addWidget(self.directoryLabel, 6, 1)
layout.addWidget(self.openFileNameButton, 7, 0)
layout.addWidget(self.openFileNameLabel, 7, 1)
layout.addWidget(self.openFileNamesButton, 8, 0)
layout.addWidget(self.openFileNamesLabel, 8, 1)
layout.addWidget(self.saveFileNameButton, 9, 0)
layout.addWidget(self.saveFileNameLabel, 9, 1)
layout.addWidget(self.criticalButton, 10, 0)
layout.addWidget(self.criticalLabel, 10, 1)
layout.addWidget(self.informationButton, 11, 0)
layout.addWidget(self.informationLabel, 11, 1)
layout.addWidget(self.questionButton, 12, 0)
layout.addWidget(self.questionLabel, 12, 1)
layout.addWidget(self.warningButton, 13, 0)
layout.addWidget(self.warningLabel, 13, 1)
layout.addWidget(self.errorButton, 14, 0)
layout.addWidget(self.errorLabel, 14, 1)
layout.addWidget(self.native, 15, 0)
self.setLayout(layout)
self.setWindowTitle("Standard Dialogs")
class WeatherStation(QApplication):
HOST = "localhost"
PORT = 4223
ipcon = None
lcd = None
al = None
al_v2 = None
al_v3 = None
hum = None
hum_v2 = None
baro = None
baro_v2 = None
projects = []
active_project = None
error_msg = None
def __init__(self, args):
super().__init__(args)
self.error_msg = QErrorMessage()
self.ipcon = IPConnection()
signal.signal(signal.SIGINT, self.exit_demo)
signal.signal(signal.SIGTERM, self.exit_demo)
timer = QTimer(self)
timer.setSingleShot(True)
timer.timeout.connect(self.connect)
timer.start(1)
def exit_demo(self, signl=None, frme=None):
try:
self.ipcon.disconnect()
self.timer.stop()
self.tabs.destroy()
except:
pass
sys.exit()
def open_gui(self):
self.main = MainWindow(self)
self.main.setFixedSize(730, 430)
self.main.setWindowIcon(QIcon(load_pixmap('starter_kit_weather_station_demo-icon.png')))
self.tabs = QTabWidget()
widget = QWidget()
layout = QVBoxLayout()
layout.addWidget(self.tabs)
widget.setLayout(layout)
self.main.setCentralWidget(widget)
self.projects.append(ProjectEnvDisplay(self.tabs, self))
self.projects.append(ProjectStatistics(self.tabs, self))
self.tabs.addTab(self.projects[0], "Display Environment Measurements")
self.tabs.addTab(self.projects[1], "Show Statistics with Button Control")
self.active_project = self.projects[0]
self.tabs.currentChanged.connect(self.tabChangedSlot)
self.main.setWindowTitle("Starter Kit: Weather Station Demo " + DEMO_VERSION)
self.main.show()
def connect(self):
try:
self.ipcon.connect(WeatherStation.HOST, WeatherStation.PORT)
except Error as e:
self.error_msg.showMessage('Connection Error: ' + str(e.description) + "\nBrickd installed and running?")
return
except socket.error as e:
self.error_msg.showMessage('Socket error: ' + str(e) + "\nBrickd installed and running?")
return
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.cb_enumerate)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.cb_connected)
try:
self.ipcon.enumerate()
except Error as e:
self.error_msg.showMessage('Enumerate Error: ' + str(e.description))
return
self.open_gui()
def tabChangedSlot(self, tabIndex):
if self.lcd is not None:
self.lcd.clear_display()
self.active_project = self.projects[tabIndex]
def cb_illuminance(self, illuminance):
for p in self.projects:
p.update_illuminance(illuminance/10.0)
def cb_illuminance_v2(self, illuminance):
for p in self.projects:
p.update_illuminance(illuminance/100.0)
def cb_illuminance_v3(self, illuminance):
for p in self.projects:
p.update_illuminance(illuminance/100.0)
def cb_humidity(self, humidity):
for p in self.projects:
p.update_humidity(humidity/10.0)
def cb_humidity_v2(self, humidity):
for p in self.projects:
p.update_humidity(humidity/100.0)
def cb_air_pressure(self, air_pressure):
for p in self.projects:
p.update_air_pressure(air_pressure/1000.0)
try:
temperature = self.baro.get_chip_temperature()
except Error as e:
print('Could not get temperature: ' + str(e.description))
return
for p in self.projects:
p.update_temperature(temperature/100.0)
def cb_air_pressure_v2(self, air_pressure):
for p in self.projects:
p.update_air_pressure(air_pressure/1000.0)
try:
temperature = self.baro_v2.get_temperature()
except Error as e:
print('Could not get temperature: ' + str(e.description))
return
for p in self.projects:
p.update_temperature(temperature/100.0)
def configure_custom_chars(self):
c = [[0x00 for x in range(8)] for y in range(8)]
c[0] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff]
c[1] = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff]
c[2] = [0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff]
c[3] = [0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff]
c[4] = [0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff]
c[5] = [0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
c[6] = [0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
c[7] = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
for i in range(len(c)):
self.lcd.set_custom_character(i, c[i]);
def cb_button_pressed(self, button):
for p in self.projects:
p.button_pressed(button)
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type == IPConnection.ENUMERATION_TYPE_CONNECTED or \
enumeration_type == IPConnection.ENUMERATION_TYPE_AVAILABLE:
if device_identifier == BrickletLCD20x4.DEVICE_IDENTIFIER:
try:
self.lcd = BrickletLCD20x4(uid, self.ipcon)
self.lcd.clear_display()
self.lcd.backlight_on()
self.lcd.register_callback(self.lcd.CALLBACK_BUTTON_PRESSED, self.cb_button_pressed)
self.configure_custom_chars()
except Error as e:
self.error_msg.showMessage('LCD 20x4 init failed: ' + str(e.description))
self.lcd = None
elif device_identifier == BrickletAmbientLight.DEVICE_IDENTIFIER:
try:
self.al = BrickletAmbientLight(uid, self.ipcon)
self.al.set_illuminance_callback_period(1000)
self.al.register_callback(self.al.CALLBACK_ILLUMINANCE,
self.cb_illuminance)
except Error as e:
self.error_msg.showMessage('Ambient Light init failed: ' + str(e.description))
self.al = None
elif device_identifier == BrickletAmbientLightV2.DEVICE_IDENTIFIER:
try:
self.al_v2 = BrickletAmbientLightV2(uid, self.ipcon)
self.al_v2.set_configuration(self.al_v2.ILLUMINANCE_RANGE_64000LUX,
self.al_v2.INTEGRATION_TIME_200MS)
self.al_v2.set_illuminance_callback_period(1000)
self.al_v2.register_callback(self.al_v2.CALLBACK_ILLUMINANCE,
self.cb_illuminance_v2)
except Error as e:
self.error_msg.showMessage('Ambient Light 2.0 init failed: ' + str(e.description))
self.al_v2 = None
elif device_identifier == BrickletAmbientLightV3.DEVICE_IDENTIFIER:
try:
self.al_v3 = BrickletAmbientLightV3(uid, self.ipcon)
self.al_v3.set_illuminance_callback_configuration(1000, False, 'x', 0, 0)
self.al_v3.register_callback(self.al_v3.CALLBACK_ILLUMINANCE,
self.cb_illuminance_v3)
except Error as e:
self.error_msg.showMessage('Ambient Light 3.0 init failed: ' + str(e.description))
self.al_v3 = None
elif device_identifier == BrickletHumidity.DEVICE_IDENTIFIER:
try:
self.hum = BrickletHumidity(uid, self.ipcon)
self.hum.set_humidity_callback_period(1000)
self.hum.register_callback(self.hum.CALLBACK_HUMIDITY,
self.cb_humidity)
except Error as e:
self.error_msg.showMessage('Humidity init failed: ' + str(e.description))
self.hum = None
elif device_identifier == BrickletHumidityV2.DEVICE_IDENTIFIER:
try:
self.hum_v2 = BrickletHumidityV2(uid, self.ipcon)
self.hum_v2.set_humidity_callback_configuration(1000, True, 'x', 0, 0)
self.hum_v2.register_callback(self.hum_v2.CALLBACK_HUMIDITY,
self.cb_humidity_v2)
except Error as e:
self.error_msg.showMessage('Humidity 2.0 init failed: ' + str(e.description))
self.hum_v2 = None
elif device_identifier == BrickletBarometer.DEVICE_IDENTIFIER:
try:
self.baro = BrickletBarometer(uid, self.ipcon)
self.baro.set_air_pressure_callback_period(1000)
self.baro.register_callback(self.baro.CALLBACK_AIR_PRESSURE,
self.cb_air_pressure)
except Error as e:
self.error_msg.showMessage('Barometer init failed: ' + str(e.description))
self.baro = None
elif device_identifier == BrickletBarometerV2.DEVICE_IDENTIFIER:
try:
self.baro_v2 = BrickletBarometerV2(uid, self.ipcon)
self.baro_v2.set_air_pressure_callback_configuration(1000, False, 'x', 0, 0)
self.baro_v2.register_callback(self.baro_v2.CALLBACK_AIR_PRESSURE,
self.cb_air_pressure_v2)
except Error as e:
self.error_msg.showMessage('Barometer 2.0 init failed: ' + str(e.description))
self.baro_v2 = None
def cb_connected(self, connected_reason):
if connected_reason == IPConnection.CONNECT_REASON_AUTO_RECONNECT:
while True:
try:
self.ipcon.enumerate()
break
except Error as e:
self.error_msg.showMessage('Enumerate Error: ' + str(e.description))
time.sleep(1)
def on_scan_error(self, error):
print('Error: %s' % error)
err = QErrorMessage(self)
err.setWindowTitle("eDocuments - scan error")
err.showMessage(error)
class Dialog(QDialog):
MESSAGE = "<p>Message boxes have a caption, a text, and up to three " \
"buttons, each with standard or custom texts.</p>" \
"<p>Click a button to close the message box. Pressing the Esc " \
"button will activate the detected escape button (if any).</p>"
def __init__(self, parent=None):
super(Dialog, self).__init__(parent)
self.openFilesPath = ''
self.errorMessageDialog = QErrorMessage(self)
frameStyle = QFrame.Sunken | QFrame.Panel
self.integerLabel = QLabel()
self.integerLabel.setFrameStyle(frameStyle)
self.integerButton = QPushButton("QInputDialog.get&Int()")
self.doubleLabel = QLabel()
self.doubleLabel.setFrameStyle(frameStyle)
self.doubleButton = QPushButton("QInputDialog.get&Double()")
self.itemLabel = QLabel()
self.itemLabel.setFrameStyle(frameStyle)
self.itemButton = QPushButton("QInputDialog.getIte&m()")
self.textLabel = QLabel()
self.textLabel.setFrameStyle(frameStyle)
self.textButton = QPushButton("QInputDialog.get&Text()")
self.colorLabel = QLabel()
self.colorLabel.setFrameStyle(frameStyle)
self.colorButton = QPushButton("QColorDialog.get&Color()")
self.fontLabel = QLabel()
self.fontLabel.setFrameStyle(frameStyle)
self.fontButton = QPushButton("QFontDialog.get&Font()")
self.directoryLabel = QLabel()
self.directoryLabel.setFrameStyle(frameStyle)
self.directoryButton = QPushButton("QFileDialog.getE&xistingDirectory()")
self.openFileNameLabel = QLabel()
self.openFileNameLabel.setFrameStyle(frameStyle)
self.openFileNameButton = QPushButton("QFileDialog.get&OpenFileName()")
self.openFileNamesLabel = QLabel()
self.openFileNamesLabel.setFrameStyle(frameStyle)
self.openFileNamesButton = QPushButton("QFileDialog.&getOpenFileNames()")
self.saveFileNameLabel = QLabel()
self.saveFileNameLabel.setFrameStyle(frameStyle)
self.saveFileNameButton = QPushButton("QFileDialog.get&SaveFileName()")
self.criticalLabel = QLabel()
self.criticalLabel.setFrameStyle(frameStyle)
self.criticalButton = QPushButton("QMessageBox.critica&l()")
self.informationLabel = QLabel()
self.informationLabel.setFrameStyle(frameStyle)
self.informationButton = QPushButton("QMessageBox.i&nformation()")
self.questionLabel = QLabel()
self.questionLabel.setFrameStyle(frameStyle)
self.questionButton = QPushButton("QMessageBox.&question()")
self.warningLabel = QLabel()
self.warningLabel.setFrameStyle(frameStyle)
self.warningButton = QPushButton("QMessageBox.&warning()")
self.errorLabel = QLabel()
self.errorLabel.setFrameStyle(frameStyle)
self.errorButton = QPushButton("QErrorMessage.show&M&essage()")
self.integerButton.clicked.connect(self.setInteger)
self.doubleButton.clicked.connect(self.setDouble)
self.itemButton.clicked.connect(self.setItem)
self.textButton.clicked.connect(self.setText)
self.colorButton.clicked.connect(self.setColor)
self.fontButton.clicked.connect(self.setFont)
self.directoryButton.clicked.connect(self.setExistingDirectory)
self.openFileNameButton.clicked.connect(self.setOpenFileName)
self.openFileNamesButton.clicked.connect(self.setOpenFileNames)
self.saveFileNameButton.clicked.connect(self.setSaveFileName)
self.criticalButton.clicked.connect(self.criticalMessage)
self.informationButton.clicked.connect(self.informationMessage)
self.questionButton.clicked.connect(self.questionMessage)
self.warningButton.clicked.connect(self.warningMessage)
self.errorButton.clicked.connect(self.errorMessage)
self.native = QCheckBox()
self.native.setText("Use native file dialog.")
self.native.setChecked(True)
if sys.platform not in ("win32", "darwin"):
self.native.hide()
layout = QGridLayout()
layout.setColumnStretch(1, 1)
layout.setColumnMinimumWidth(1, 250)
layout.addWidget(self.integerButton, 0, 0)
layout.addWidget(self.integerLabel, 0, 1)
layout.addWidget(self.doubleButton, 1, 0)
layout.addWidget(self.doubleLabel, 1, 1)
layout.addWidget(self.itemButton, 2, 0)
layout.addWidget(self.itemLabel, 2, 1)
layout.addWidget(self.textButton, 3, 0)
layout.addWidget(self.textLabel, 3, 1)
layout.addWidget(self.colorButton, 4, 0)
layout.addWidget(self.colorLabel, 4, 1)
layout.addWidget(self.fontButton, 5, 0)
layout.addWidget(self.fontLabel, 5, 1)
layout.addWidget(self.directoryButton, 6, 0)
layout.addWidget(self.directoryLabel, 6, 1)
layout.addWidget(self.openFileNameButton, 7, 0)
layout.addWidget(self.openFileNameLabel, 7, 1)
layout.addWidget(self.openFileNamesButton, 8, 0)
layout.addWidget(self.openFileNamesLabel, 8, 1)
layout.addWidget(self.saveFileNameButton, 9, 0)
layout.addWidget(self.saveFileNameLabel, 9, 1)
layout.addWidget(self.criticalButton, 10, 0)
layout.addWidget(self.criticalLabel, 10, 1)
layout.addWidget(self.informationButton, 11, 0)
layout.addWidget(self.informationLabel, 11, 1)
layout.addWidget(self.questionButton, 12, 0)
layout.addWidget(self.questionLabel, 12, 1)
layout.addWidget(self.warningButton, 13, 0)
layout.addWidget(self.warningLabel, 13, 1)
layout.addWidget(self.errorButton, 14, 0)
layout.addWidget(self.errorLabel, 14, 1)
layout.addWidget(self.native, 15, 0)
self.setLayout(layout)
self.setWindowTitle("Standard Dialogs")
def setInteger(self):
i, ok = QInputDialog.getInt(self, "QInputDialog.getInt()",
"Percentage:", 25, 0, 100, 1)
if ok:
self.integerLabel.setText("%d%%" % i)
def setDouble(self):
d, ok = QInputDialog.getDouble(self, "QInputDialog.getDouble()",
"Amount:", 37.56, -10000, 10000, 2)
if ok:
self.doubleLabel.setText("$%g" % d)
def setItem(self):
items = ("Spring", "Summer", "Fall", "Winter")
item, ok = QInputDialog.getItem(self, "QInputDialog.getItem()",
"Season:", items, 0, False)
if ok and item:
self.itemLabel.setText(item)
def setText(self):
text, ok = QInputDialog.getText(self, "QInputDialog.getText()",
"User name:", QLineEdit.Normal, QDir.home().dirName())
if ok and text != '':
self.textLabel.setText(text)
def setColor(self):
color = QColorDialog.getColor(Qt.green, self)
if color.isValid():
self.colorLabel.setText(color.name())
self.colorLabel.setPalette(QPalette(color))
self.colorLabel.setAutoFillBackground(True)
def setFont(self):
font, ok = QFontDialog.getFont(QFont(self.fontLabel.text()), self)
if ok:
self.fontLabel.setText(font.key())
self.fontLabel.setFont(font)
def setExistingDirectory(self):
options = QFileDialog.DontResolveSymlinks | QFileDialog.ShowDirsOnly
directory = QFileDialog.getExistingDirectory(self,
"QFileDialog.getExistingDirectory()",
self.directoryLabel.text(), options=options)
if directory:
self.directoryLabel.setText(directory)
def setOpenFileName(self):
options = QFileDialog.Options()
if not self.native.isChecked():
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getOpenFileName(self,
"QFileDialog.getOpenFileName()", self.openFileNameLabel.text(),
"All Files (*);;Text Files (*.txt)", options=options)
if fileName:
self.openFileNameLabel.setText(fileName)
def setOpenFileNames(self):
options = QFileDialog.Options()
if not self.native.isChecked():
options |= QFileDialog.DontUseNativeDialog
files, _ = QFileDialog.getOpenFileNames(self,
"QFileDialog.getOpenFileNames()", self.openFilesPath,
"All Files (*);;Text Files (*.txt)", options=options)
if files:
self.openFilesPath = files[0]
self.openFileNamesLabel.setText("[%s]" % ', '.join(files))
def setSaveFileName(self):
options = QFileDialog.Options()
if not self.native.isChecked():
options |= QFileDialog.DontUseNativeDialog
fileName, _ = QFileDialog.getSaveFileName(self,
"QFileDialog.getSaveFileName()",
self.saveFileNameLabel.text(),
"All Files (*);;Text Files (*.txt)", options=options)
if fileName:
self.saveFileNameLabel.setText(fileName)
def criticalMessage(self):
reply = QMessageBox.critical(self, "QMessageBox.critical()",
Dialog.MESSAGE,
QMessageBox.Abort | QMessageBox.Retry | QMessageBox.Ignore)
if reply == QMessageBox.Abort:
self.criticalLabel.setText("Abort")
elif reply == QMessageBox.Retry:
self.criticalLabel.setText("Retry")
else:
self.criticalLabel.setText("Ignore")
def informationMessage(self):
reply = QMessageBox.information(self,
"QMessageBox.information()", Dialog.MESSAGE)
if reply == QMessageBox.Ok:
self.informationLabel.setText("OK")
else:
self.informationLabel.setText("Escape")
def questionMessage(self):
reply = QMessageBox.question(self, "QMessageBox.question()",
Dialog.MESSAGE,
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if reply == QMessageBox.Yes:
self.questionLabel.setText("Yes")
elif reply == QMessageBox.No:
self.questionLabel.setText("No")
else:
self.questionLabel.setText("Cancel")
def warningMessage(self):
msgBox = QMessageBox(QMessageBox.Warning, "QMessageBox.warning()",
Dialog.MESSAGE, QMessageBox.NoButton, self)
msgBox.addButton("Save &Again", QMessageBox.AcceptRole)
msgBox.addButton("&Continue", QMessageBox.RejectRole)
if msgBox.exec_() == QMessageBox.AcceptRole:
self.warningLabel.setText("Save Again")
else:
self.warningLabel.setText("Continue")
def errorMessage(self):
self.errorMessageDialog.showMessage("This dialog shows and remembers "
"error messages. If the checkbox is checked (as it is by "
"default), the shown message will be shown again, but if the "
"user unchecks the box the message will not appear again if "
"QErrorMessage.showMessage() is called with the same message.")
self.errorLabel.setText("If the box is unchecked, the message won't "
"appear again.")
